gt 2.14.35 → 2.14.37

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

@@ -1,425 +1,298 @@
-import * as t from '@babel/types';
-import { INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, STRING_REGISTRATION_FUNCS, T_GLOBAL_REGISTRATION_FUNCTION_MARKER, } from './constants.js';
-import { warnAsyncUseGT, warnSyncGetGT, warnUnresolvedImportSync, } from '../../../console/index.js';
-import traverseModule from '@babel/traverse';
-// Handle CommonJS/ESM interop
+import { STRING_REGISTRATION_FUNCS } from "./constants.js";
+import { warnAsyncUseGT, warnSyncGetGT, warnUnresolvedImportSync } from "../../../console/index.js";
+import { resolveImportPath } from "./resolveImportPath.js";
+import { buildImportMap } from "./buildImportMap.js";
+import { processTranslationCall } from "./stringParsing/processTranslationCall/index.js";
+import { processTaggedTemplateCall } from "./stringParsing/processTaggedTemplateCall/index.js";
+import fs from "node:fs";
+import * as t from "@babel/types";
+import { parse } from "@babel/parser";
+import traverseModule from "@babel/traverse";
+//#region src/react/jsx/utils/parseStringFunction.ts
 const traverse = traverseModule.default || traverseModule;
-import fs from 'node:fs';
-import { parse } from '@babel/parser';
-import { resolveImportPath } from './resolveImportPath.js';
-import { buildImportMap } from './buildImportMap.js';
-import { processTranslationCall } from './stringParsing/processTranslationCall/index.js';
-import { processTaggedTemplateCall } from './stringParsing/processTaggedTemplateCall/index.js';
 /**
- * Cache for resolved import paths to avoid redundant I/O operations.
- * Key: `${currentFile}::${importPath}`
- * Value: resolved absolute path or null
- */
-const resolveImportPathCache = new Map();
+* Cache for resolved import paths to avoid redundant I/O operations.
+* Key: `${currentFile}::${importPath}`
+* Value: resolved absolute path or null
+*/
+const resolveImportPathCache = /* @__PURE__ */ new Map();
 /**
- * Cache for processed functions to avoid re-parsing the same files.
- * Key: `${filePath}::${functionName}::${argIndex}`
- * Value: boolean indicating whether the function was found and processed
- */
-const processFunctionCache = new Map();
+* Cache for processed functions to avoid re-parsing the same files.
+* Key: `${filePath}::${functionName}::${argIndex}`
+* Value: boolean indicating whether the function was found and processed
+*/
+const processFunctionCache = /* @__PURE__ */ new Map();
 /**
- * Clears all caches. Useful for testing or when file system changes.
- */
-export function clearParsingCaches() {
-    resolveImportPathCache.clear();
-    processFunctionCache.clear();
+* Clears all caches. Useful for testing or when file system changes.
+*/
+function clearParsingCaches() {
+	resolveImportPathCache.clear();
+	processFunctionCache.clear();
 }
 /**
- * Extracts the parameter name from a function parameter node, handling TypeScript annotations and default values.
- */
+* Extracts the parameter name from a function parameter node, handling TypeScript annotations and default values.
+*/
 function extractParameterName(param) {
-    if (t.isIdentifier(param)) {
-        return param.name;
-    }
-    // Handle parameters with default values: (gt = () => {})
-    if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
-        return param.left.name;
-    }
-    return null;
+	if (t.isIdentifier(param)) return param.name;
+	if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) return param.left.name;
+	return null;
 }
 /**
- * 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 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;
+* 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 = /* @__PURE__ */ new Set()) {
+	if (visited.has(variableName)) return [];
+	visited.add(variableName);
+	const aliases = [variableName];
+	if (scope.bindings[variableName]) 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) {
+			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 (gt('hello')) and prop drilling
- * where the translation callback is passed to other functions (getData(gt)).
- */
+* Handles how translation callbacks are used within code.
+* This covers both direct translation calls (gt('hello')) and prop drilling
+* where the translation callback is passed to other functions (getData(gt)).
+*/
 function handleFunctionCall(tPath, config, state, output, visitedFunctions) {
-    if (tPath.parent.type === 'CallExpression' &&
-        tPath.parent.callee === tPath.node) {
-        // Direct translation call: t('hello')
-        processTranslationCall(tPath, config, output);
-    }
-    else if (!config.ignoreTaggedTemplates &&
-        tPath.parent.type === 'TaggedTemplateExpression' &&
-        tPath.parent.tag === tPath.node) {
-        // Tagged template: t`hello ${name}`
-        processTaggedTemplateCall(tPath, config, output);
-    }
-    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, config, output, visitedFunctions);
-            }
-            // 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, config, output, visitedFunctions);
-            }
-            // If not found locally, check if it's an imported function
-            else if (state.importMap.has(callee.name)) {
-                const importPath = state.importMap.get(callee.name);
-                const resolvedPath = resolveImportPath(config.file, importPath, config.parsingOptions, resolveImportPathCache);
-                if (resolvedPath) {
-                    processFunctionInFile(resolvedPath, callee.name, argIndex, config, state, output);
-                }
-                else {
-                    output.warnings.add(warnUnresolvedImportSync(config.file, callee.name, importPath, tPath.node.loc
-                        ? `${tPath.node.loc.start.line}:${tPath.node.loc.start.column}`
-                        : undefined));
-                }
-            }
-        }
-    }
+	if (tPath.parent.type === "CallExpression" && tPath.parent.callee === tPath.node) processTranslationCall(tPath, config, output);
+	else if (!config.ignoreTaggedTemplates && tPath.parent.type === "TaggedTemplateExpression" && tPath.parent.tag === tPath.node) processTaggedTemplateCall(tPath, config, output);
+	else if (tPath.parent.type === "CallExpression" && t.isExpression(tPath.node) && tPath.parent.arguments.includes(tPath.node)) {
+		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, config, output, visitedFunctions);
+			} 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, config, output, visitedFunctions);
+			} else if (state.importMap.has(callee.name)) {
+				const importPath = state.importMap.get(callee.name);
+				const resolvedPath = resolveImportPath(config.file, importPath, config.parsingOptions, resolveImportPathCache);
+				if (resolvedPath) processFunctionInFile(resolvedPath, callee.name, argIndex, config, state, output);
+				else output.warnings.add(warnUnresolvedImportSync(config.file, callee.name, importPath, tPath.node.loc ? `${tPath.node.loc.start.line}:${tPath.node.loc.start.column}` : void 0));
+			}
+		}
+	}
 }
 /**
- * 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.
- */
+* 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, config, output, visitedFunctions) {
-    if (visitedFunctions.has(functionNode))
-        return;
-    visitedFunctions.add(functionNode);
-    if (functionNode.params.length > argIndex) {
-        const param = functionNode.params[argIndex];
-        const paramName = extractParameterName(param);
-        if (paramName) {
-            findFunctionParameterUsage(functionPath, paramName, config, output, visitedFunctions);
-        }
-    }
-    visitedFunctions.delete(functionNode);
+	if (visitedFunctions.has(functionNode)) return;
+	visitedFunctions.add(functionNode);
+	if (functionNode.params.length > argIndex) {
+		const param = functionNode.params[argIndex];
+		const paramName = extractParameterName(param);
+		if (paramName) findFunctionParameterUsage(functionPath, paramName, config, output, visitedFunctions);
+	}
+	visitedFunctions.delete(functionNode);
 }
 /**
- * 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.
- */
+* 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, config, output, visitedFunctions) {
-    // 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, config, { visited: new Set(), importMap }, output, visitedFunctions);
-                });
-            }
-        });
-    }
+	if (functionPath.isFunction()) {
+		const functionScope = functionPath.scope;
+		const allParameterNames = resolveVariableAliases(functionScope, parameterName);
+		const programPath = functionPath.scope.getProgramParent().path;
+		const importMap = buildImportMap(programPath);
+		allParameterNames.forEach((name) => {
+			const binding = functionScope.bindings[name];
+			if (binding) binding.referencePaths.forEach((refPath) => {
+				handleFunctionCall(refPath, config, {
+					visited: /* @__PURE__ */ new Set(),
+					importMap
+				}, output, visitedFunctions);
+			});
+		});
+	}
 }
 /**
- * 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) => { ... }
- *
- * If the function is not found in the file, follows re-exports (export * from './other')
- */
+* 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) => { ... }
+*
+* If the function is not found in the file, follows re-exports (export * from './other')
+*/
 function processFunctionInFile(filePath, functionName, argIndex, config, state, output) {
-    // Check cache first to avoid redundant parsing
-    const cacheKey = `${filePath}::${functionName}::${argIndex}`;
-    if (processFunctionCache.has(cacheKey)) {
-        return;
-    }
-    // Prevent infinite loops from circular re-exports
-    if (state.visited.has(filePath)) {
-        return;
-    }
-    state.visited.add(filePath);
-    try {
-        const code = fs.readFileSync(filePath, 'utf8');
-        const ast = parse(code, {
-            sourceType: 'module',
-            plugins: ['jsx', 'typescript'],
-        });
-        let found = false;
-        const reExports = [];
-        // Fresh set per cross-file parse — node identity is only stable within a single parse.
-        // Cross-file cycles are already guarded by processFunctionCache above.
-        const visitedFunctions = new Set();
-        // Update config.file so relative imports in the target file resolve correctly
-        const crossFileConfig = { ...config, file: filePath };
-        traverse(ast, {
-            // Handle function declarations: function getInfo(t) { ... }
-            FunctionDeclaration(path) {
-                if (path.node.id?.name === functionName) {
-                    found = true;
-                    processFunctionIfMatches(functionName, argIndex, path.node, path, crossFileConfig, output, visitedFunctions);
-                }
-            },
-            // 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))) {
-                    found = true;
-                    const initPath = path.get('init');
-                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, crossFileConfig, output, visitedFunctions);
-                }
-            },
-            // Collect re-exports: export * from './other'
-            ExportAllDeclaration(path) {
-                if (t.isStringLiteral(path.node.source)) {
-                    reExports.push(path.node.source.value);
-                }
-            },
-            // Collect named re-exports: export { foo } from './other'
-            ExportNamedDeclaration(path) {
-                if (path.node.source && t.isStringLiteral(path.node.source)) {
-                    // Check if this export includes our function
-                    const exportsFunction = path.node.specifiers.some((spec) => {
-                        if (t.isExportSpecifier(spec)) {
-                            const exportedName = t.isIdentifier(spec.exported)
-                                ? spec.exported.name
-                                : spec.exported.value;
-                            return exportedName === functionName;
-                        }
-                        return false;
-                    });
-                    if (exportsFunction) {
-                        reExports.push(path.node.source.value);
-                    }
-                }
-            },
-        });
-        // If function not found, follow re-exports
-        if (!found && reExports.length > 0) {
-            for (const reExportPath of reExports) {
-                const resolvedPath = resolveImportPath(filePath, reExportPath, config.parsingOptions, resolveImportPathCache);
-                if (resolvedPath) {
-                    processFunctionInFile(resolvedPath, functionName, argIndex, config, state, output);
-                }
-            }
-        }
-        // Mark this function search as processed in the cache
-        processFunctionCache.set(cacheKey, found);
-    }
-    catch {
-        // Silently skip files that can't be parsed or accessed
-        // Still mark as processed to avoid retrying failed parses
-        processFunctionCache.set(cacheKey, false);
-    }
+	const cacheKey = `${filePath}::${functionName}::${argIndex}`;
+	if (processFunctionCache.has(cacheKey)) return;
+	if (state.visited.has(filePath)) return;
+	state.visited.add(filePath);
+	try {
+		const ast = parse(fs.readFileSync(filePath, "utf8"), {
+			sourceType: "module",
+			plugins: ["jsx", "typescript"]
+		});
+		let found = false;
+		const reExports = [];
+		const visitedFunctions = /* @__PURE__ */ new Set();
+		const crossFileConfig = {
+			...config,
+			file: filePath
+		};
+		traverse(ast, {
+			FunctionDeclaration(path) {
+				if (path.node.id?.name === functionName) {
+					found = true;
+					processFunctionIfMatches(functionName, argIndex, path.node, path, crossFileConfig, output, visitedFunctions);
+				}
+			},
+			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))) {
+					found = true;
+					const initPath = path.get("init");
+					processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, crossFileConfig, output, visitedFunctions);
+				}
+			},
+			ExportAllDeclaration(path) {
+				if (t.isStringLiteral(path.node.source)) reExports.push(path.node.source.value);
+			},
+			ExportNamedDeclaration(path) {
+				if (path.node.source && t.isStringLiteral(path.node.source)) {
+					if (path.node.specifiers.some((spec) => {
+						if (t.isExportSpecifier(spec)) return (t.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value) === functionName;
+						return false;
+					})) reExports.push(path.node.source.value);
+				}
+			}
+		});
+		if (!found && reExports.length > 0) for (const reExportPath of reExports) {
+			const resolvedPath = resolveImportPath(filePath, reExportPath, config.parsingOptions, resolveImportPathCache);
+			if (resolvedPath) processFunctionInFile(resolvedPath, functionName, argIndex, config, state, output);
+		}
+		processFunctionCache.set(cacheKey, found);
+	} catch {
+		processFunctionCache.set(cacheKey, false);
+	}
 }
 /**
- * Main entry point for parsing translation strings from useGT() and getGT() calls.
- *
- * Supports complex patterns including:
- * 1. Direct calls: const gt = useGT(); gt('hello');
- * 2. Translation callback prop drilling: const gt = useGT(); getInfo(gt); where getInfo uses gt() internally
- * 3. Cross-file function calls: imported functions that receive the translation callback as a parameter
- *
- * Example flow:
- * - const gt = useGT();
- * - const { home } = getInfo(gt); // getInfo is imported from './constants'
- * - This will parse constants.ts to find translation calls within getInfo function
- */
-export function parseStrings(importName, originalName, path, config, output) {
-    // Handle global t macro directly — path is already the tag identifier
-    // NOTE: if we decide to add support for a global t() function in addition to the macro,
-    // then we need to add support for skipDeriveInvocation here
-    if (originalName === T_GLOBAL_REGISTRATION_FUNCTION_MARKER) {
-        if (!config.ignoreGlobalTaggedTemplates) {
-            processTaggedTemplateCall(path, {
-                ...config,
-                autoderiveMethod: config.autoderiveMethod === 'AUTO'
-                    ? 'DISABLED'
-                    : config.autoderiveMethod,
-            }, output);
-        }
-        return;
-    }
-    // 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(), t() calls directly without variable assignment
-        if (STRING_REGISTRATION_FUNCS.includes(originalName)) {
-            const stringRegistrationConfig = {
-                parsingOptions: config.parsingOptions,
-                file: config.file,
-                ignoreInlineMetadata: false,
-                ignoreDynamicContent: false,
-                ignoreInvalidIcu: false,
-                ignoreInlineListContent: false,
-                includeSourceCodeContext: config.includeSourceCodeContext,
-                ignoreTaggedTemplates: false,
-                ignoreGlobalTaggedTemplates: false,
-                // User configurable, otherwise default to AUTO
-                autoderiveMethod: config.autoderiveMethod === 'AUTO'
-                    ? 'DISABLED'
-                    : config.autoderiveMethod,
-            };
-            // Check if this is a direct call to msg('string') or t('string')
-            if (refPath.parent.type === 'CallExpression' &&
-                refPath.parent.callee === refPath.node) {
-                /**
-                 * CASE: Autoderive t() and msg() function
-                 * The t() function, will treat variable content as if it was marked for derivation
-                 * without explicit calls to derive().
-                 *
-                 * @example
-                 * const derivedValue = 'John';
-                 * const interpolatedValue = "Ernest"
-                 * t(
-                 *   "Hello, " + derivedValue + "! My name is {interpolatedValue}",
-                 *   { interpolatedValue }
-                 * );
-                 * // "Hello, John! My name is {interpolatedValue}"
-                 */
-                processTranslationCall(refPath, config.autoderiveMethod === 'AUTO'
-                    ? {
-                        ...stringRegistrationConfig,
-                        autoderiveMethod: 'ENABLED',
-                    }
-                    : stringRegistrationConfig, output);
-            }
-            else if (!stringRegistrationConfig.ignoreTaggedTemplates &&
-                refPath.parent.type === 'TaggedTemplateExpression' &&
-                refPath.parent.tag === refPath.node) {
-                // Tagged template: t`hello ${name}`
-                processTaggedTemplateCall(refPath, stringRegistrationConfig, output);
-            }
-            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)) {
-                output.errors.push(warnAsyncUseGT(config.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)) {
-                output.errors.push(warnSyncGetGT(config.file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
-                return;
-            }
-            const isMessageHook = originalName === INLINE_MESSAGE_HOOK ||
-                originalName === INLINE_MESSAGE_HOOK_ASYNC;
-            const isInlineGT = originalName === INLINE_TRANSLATION_HOOK ||
-                originalName === INLINE_TRANSLATION_HOOK_ASYNC;
-            const hookConfig = {
-                parsingOptions: config.parsingOptions,
-                file: config.file,
-                ignoreInlineMetadata: isMessageHook,
-                ignoreDynamicContent: isMessageHook,
-                ignoreInvalidIcu: isMessageHook,
-                // TODO: when we add support for array content in gt function, this should just always be false
-                ignoreInlineListContent: isInlineGT,
-                includeSourceCodeContext: config.includeSourceCodeContext,
-                ignoreTaggedTemplates: false,
-                ignoreGlobalTaggedTemplates: false,
-                // User configurable, otherwise default to DISABLED
-                autoderiveMethod: config.autoderiveMethod === 'AUTO'
-                    ? isInlineGT
-                        ? 'ENABLED'
-                        : 'DISABLED'
-                    : config.autoderiveMethod,
-            };
-            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
-                const visitedFunctions = new Set();
-                allTranslationNames.forEach((name) => {
-                    const tReferencePaths = variableScope.bindings[name]?.referencePaths || [];
-                    for (const tPath of tReferencePaths) {
-                        handleFunctionCall(tPath, hookConfig, { visited: new Set(), importMap }, output, visitedFunctions);
-                    }
-                });
-            }
-        }
-    }
+* Main entry point for parsing translation strings from useGT() and getGT() calls.
+*
+* Supports complex patterns including:
+* 1. Direct calls: const gt = useGT(); gt('hello');
+* 2. Translation callback prop drilling: const gt = useGT(); getInfo(gt); where getInfo uses gt() internally
+* 3. Cross-file function calls: imported functions that receive the translation callback as a parameter
+*
+* Example flow:
+* - const gt = useGT();
+* - const { home } = getInfo(gt); // getInfo is imported from './constants'
+* - This will parse constants.ts to find translation calls within getInfo function
+*/
+function parseStrings(importName, originalName, path, config, output) {
+	if (originalName === "_gt_internal_t_global_registration_marker") {
+		if (!config.ignoreGlobalTaggedTemplates) processTaggedTemplateCall(path, {
+			...config,
+			autoderiveMethod: config.autoderiveMethod === "AUTO" ? "DISABLED" : config.autoderiveMethod
+		}, output);
+		return;
+	}
+	const importMap = buildImportMap(path.scope.getProgramParent().path);
+	const referencePaths = path.scope.bindings[importName]?.referencePaths || [];
+	for (const refPath of referencePaths) {
+		if (STRING_REGISTRATION_FUNCS.includes(originalName)) {
+			const stringRegistrationConfig = {
+				parsingOptions: config.parsingOptions,
+				file: config.file,
+				ignoreInlineMetadata: false,
+				ignoreDynamicContent: false,
+				ignoreInvalidIcu: false,
+				ignoreInlineListContent: false,
+				includeSourceCodeContext: config.includeSourceCodeContext,
+				ignoreTaggedTemplates: false,
+				ignoreGlobalTaggedTemplates: false,
+				autoderiveMethod: config.autoderiveMethod === "AUTO" ? "DISABLED" : config.autoderiveMethod
+			};
+			if (refPath.parent.type === "CallExpression" && refPath.parent.callee === refPath.node)
+ /**
+			* CASE: Autoderive t() and msg() function
+			* The t() function, will treat variable content as if it was marked for derivation
+			* without explicit calls to derive().
+			*
+			* @example
+			* const derivedValue = 'John';
+			* const interpolatedValue = "Ernest"
+			* t(
+			*   "Hello, " + derivedValue + "! My name is {interpolatedValue}",
+			*   { interpolatedValue }
+			* );
+			* // "Hello, John! My name is {interpolatedValue}"
+			*/
+			processTranslationCall(refPath, config.autoderiveMethod === "AUTO" ? {
+				...stringRegistrationConfig,
+				autoderiveMethod: "ENABLED"
+			} : stringRegistrationConfig, output);
+			else if (!stringRegistrationConfig.ignoreTaggedTemplates && refPath.parent.type === "TaggedTemplateExpression" && refPath.parent.tag === refPath.node) processTaggedTemplateCall(refPath, stringRegistrationConfig, output);
+			continue;
+		}
+		const callExpr = refPath.findParent((p) => p.isCallExpression());
+		if (callExpr) {
+			const parentPath = callExpr.parentPath;
+			const asyncScope = refPath.getFunctionParent()?.node.async;
+			if (asyncScope && (originalName === "useGT" || originalName === "useMessages")) {
+				output.errors.push(warnAsyncUseGT(config.file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
+				return;
+			} else if (!asyncScope && (originalName === "getGT" || originalName === "getMessages")) {
+				output.errors.push(warnSyncGetGT(config.file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
+				return;
+			}
+			const isMessageHook = originalName === "useMessages" || originalName === "getMessages";
+			const isInlineGT = originalName === "useGT" || originalName === "getGT";
+			const hookConfig = {
+				parsingOptions: config.parsingOptions,
+				file: config.file,
+				ignoreInlineMetadata: isMessageHook,
+				ignoreDynamicContent: isMessageHook,
+				ignoreInvalidIcu: isMessageHook,
+				ignoreInlineListContent: isInlineGT,
+				includeSourceCodeContext: config.includeSourceCodeContext,
+				ignoreTaggedTemplates: false,
+				ignoreGlobalTaggedTemplates: false,
+				autoderiveMethod: config.autoderiveMethod === "AUTO" ? isInlineGT ? "ENABLED" : "DISABLED" : config.autoderiveMethod
+			};
+			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;
+				const variableScope = effectiveParent.scope;
+				const allTranslationNames = resolveVariableAliases(variableScope, tFuncName);
+				const visitedFunctions = /* @__PURE__ */ new Set();
+				allTranslationNames.forEach((name) => {
+					const tReferencePaths = variableScope.bindings[name]?.referencePaths || [];
+					for (const tPath of tReferencePaths) handleFunctionCall(tPath, hookConfig, {
+						visited: /* @__PURE__ */ new Set(),
+						importMap
+					}, output, visitedFunctions);
+				});
+			}
+		}
+	}
 }
+//#endregion
+export { clearParsingCaches, parseStrings, resolveVariableAliases };
+
+//# sourceMappingURL=parseStringFunction.js.map