gt 2.14.35 → 2.14.36

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

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

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

@@ -1,111 +1,107 @@
-import { createMatchPath, loadConfig } from 'tsconfig-paths';
-import fs from 'node:fs';
-import path from 'node:path';
-import resolve from 'resolve';
-import enhancedResolve from 'enhanced-resolve';
+import path from "node:path";
+import fs from "node:fs";
+import { createMatchPath, loadConfig } from "tsconfig-paths";
+import resolve from "resolve";
+import enhancedResolve from "enhanced-resolve";
+//#region src/react/jsx/utils/resolveImportPath.ts
 const { ResolverFactory } = enhancedResolve;
 /**
- * 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'
- */
-export function resolveImportPath(currentFile, importPath, parsingOptions, resolveImportPathCache) {
-    // Check cache first
-    const cacheKey = `${currentFile}::${importPath}`;
-    if (resolveImportPathCache.has(cacheKey)) {
-        return resolveImportPathCache.get(cacheKey);
-    }
-    const basedir = path.dirname(currentFile);
-    const extensions = ['.tsx', '.ts', '.jsx', '.js'];
-    const mainFields = ['module', 'main'];
-    let result = null;
-    // 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, mainFields);
-        // First try without any extension
-        let tsResolved = matchPath(importPath);
-        if (tsResolved && fs.existsSync(tsResolved)) {
-            result = tsResolved;
-            resolveImportPathCache.set(cacheKey, result);
-            return result;
-        }
-        // Then try with each extension
-        for (const ext of extensions) {
-            tsResolved = matchPath(importPath + ext);
-            if (tsResolved && fs.existsSync(tsResolved)) {
-                result = tsResolved;
-                resolveImportPathCache.set(cacheKey, result);
-                return result;
-            }
-            // Also try the resolved path with extension
-            tsResolved = matchPath(importPath);
-            if (tsResolved) {
-                const resolvedWithExt = tsResolved + ext;
-                if (fs.existsSync(resolvedWithExt)) {
-                    result = resolvedWithExt;
-                    resolveImportPathCache.set(cacheKey, result);
-                    return result;
-                }
-            }
-        }
-    }
-    // 2. Try enhanced-resolve (handles package.json exports field and modern resolution)
-    try {
-        const resolver = ResolverFactory.createResolver({
-            useSyncFileSystemCalls: true,
-            fileSystem: fs,
-            extensions,
-            // Include 'development' condition to resolve to source files in monorepos
-            conditionNames: parsingOptions.conditionNames, // defaults to ['browser', 'module', 'import', 'require', 'default']. See generateSettings.ts for more details
-            exportsFields: ['exports'],
-            mainFields,
-        });
-        const resolved = resolver.resolveSync({}, basedir, importPath);
-        if (resolved) {
-            result = resolved;
-            resolveImportPathCache.set(cacheKey, result);
-            return result;
-        }
-    }
-    catch {
-        // Fall through to next resolution strategy
-    }
-    // 3. Fallback to Node.js resolution (handles relative paths and node_modules)
-    try {
-        result = resolve.sync(importPath, { basedir, extensions });
-        resolveImportPathCache.set(cacheKey, result);
-        return result;
-    }
-    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 {
-                result = resolve.sync(tsPath, { basedir, extensions });
-                resolveImportPathCache.set(cacheKey, result);
-                return result;
-            }
-            catch {
-                // Continue to return null
-            }
-        }
-        else if (importPath.endsWith('.jsx')) {
-            const tsxPath = importPath.replace(/\.jsx$/, '.tsx');
-            try {
-                result = resolve.sync(tsxPath, { basedir, extensions });
-                resolveImportPathCache.set(cacheKey, result);
-                return result;
-            }
-            catch {
-                // Continue to return null
-            }
-        }
-        resolveImportPathCache.set(cacheKey, null);
-        return null;
-    }
+* 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, parsingOptions, resolveImportPathCache) {
+	const cacheKey = `${currentFile}::${importPath}`;
+	if (resolveImportPathCache.has(cacheKey)) return resolveImportPathCache.get(cacheKey);
+	const basedir = path.dirname(currentFile);
+	const extensions = [
+		".tsx",
+		".ts",
+		".jsx",
+		".js"
+	];
+	const mainFields = ["module", "main"];
+	let result = null;
+	const tsConfigResult = loadConfig(basedir);
+	if (tsConfigResult.resultType === "success") {
+		const matchPath = createMatchPath(tsConfigResult.absoluteBaseUrl, tsConfigResult.paths, mainFields);
+		let tsResolved = matchPath(importPath);
+		if (tsResolved && fs.existsSync(tsResolved)) {
+			result = tsResolved;
+			resolveImportPathCache.set(cacheKey, result);
+			return result;
+		}
+		for (const ext of extensions) {
+			tsResolved = matchPath(importPath + ext);
+			if (tsResolved && fs.existsSync(tsResolved)) {
+				result = tsResolved;
+				resolveImportPathCache.set(cacheKey, result);
+				return result;
+			}
+			tsResolved = matchPath(importPath);
+			if (tsResolved) {
+				const resolvedWithExt = tsResolved + ext;
+				if (fs.existsSync(resolvedWithExt)) {
+					result = resolvedWithExt;
+					resolveImportPathCache.set(cacheKey, result);
+					return result;
+				}
+			}
+		}
+	}
+	try {
+		const resolved = ResolverFactory.createResolver({
+			useSyncFileSystemCalls: true,
+			fileSystem: fs,
+			extensions,
+			conditionNames: parsingOptions.conditionNames,
+			exportsFields: ["exports"],
+			mainFields
+		}).resolveSync({}, basedir, importPath);
+		if (resolved) {
+			result = resolved;
+			resolveImportPathCache.set(cacheKey, result);
+			return result;
+		}
+	} catch {}
+	try {
+		result = resolve.sync(importPath, {
+			basedir,
+			extensions
+		});
+		resolveImportPathCache.set(cacheKey, result);
+		return result;
+	} catch {
+		if (importPath.endsWith(".js")) {
+			const tsPath = importPath.replace(/\.js$/, ".ts");
+			try {
+				result = resolve.sync(tsPath, {
+					basedir,
+					extensions
+				});
+				resolveImportPathCache.set(cacheKey, result);
+				return result;
+			} catch {}
+		} else if (importPath.endsWith(".jsx")) {
+			const tsxPath = importPath.replace(/\.jsx$/, ".tsx");
+			try {
+				result = resolve.sync(tsxPath, {
+					basedir,
+					extensions
+				});
+				resolveImportPathCache.set(cacheKey, result);
+				return result;
+			} catch {}
+		}
+		resolveImportPathCache.set(cacheKey, null);
+		return null;
+	}
 }
+//#endregion
+export { resolveImportPath };
+
+//# sourceMappingURL=resolveImportPath.js.map

package/dist/react/jsx/utils/resolveImportPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveImportPath.js","names":[],"sources":["../../../../src/react/jsx/utils/resolveImportPath.ts"],"sourcesContent":["import { createMatchPath, loadConfig } from 'tsconfig-paths';\nimport { ParsingConfigOptions } from '../../../types/parsing.js';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport resolve from 'resolve';\nimport enhancedResolve from 'enhanced-resolve';\nimport type { FileSystem } from 'enhanced-resolve';\nconst { ResolverFactory } = enhancedResolve;\n\n/**\n * Resolves import paths to absolute file paths using battle-tested libraries.\n * Handles relative paths, TypeScript paths, and node module resolution.\n *\n * Examples:\n * - './constants' -> '/full/path/to/constants.ts'\n * - '@/components/ui/button' -> '/full/path/to/src/components/ui/button.tsx'\n * - '@shared/utils' -> '/full/path/to/packages/utils/index.ts'\n */\nexport function resolveImportPath(\n  currentFile: string,\n  importPath: string,\n  parsingOptions: ParsingConfigOptions,\n  resolveImportPathCache: Map<string, string | null>\n): string | null {\n  // Check cache first\n  const cacheKey = `${currentFile}::${importPath}`;\n  if (resolveImportPathCache.has(cacheKey)) {\n    return resolveImportPathCache.get(cacheKey)!;\n  }\n\n  const basedir = path.dirname(currentFile);\n  const extensions = ['.tsx', '.ts', '.jsx', '.js'];\n  const mainFields = ['module', 'main'];\n\n  let result: string | null = null;\n\n  // 1. Try tsconfig-paths resolution first (handles TypeScript path mapping)\n  const tsConfigResult = loadConfig(basedir);\n  if (tsConfigResult.resultType === 'success') {\n    const matchPath = createMatchPath(\n      tsConfigResult.absoluteBaseUrl,\n      tsConfigResult.paths,\n      mainFields\n    );\n\n    // First try without any extension\n    let tsResolved = matchPath(importPath);\n    if (tsResolved && fs.existsSync(tsResolved)) {\n      result = tsResolved;\n      resolveImportPathCache.set(cacheKey, result);\n      return result;\n    }\n\n    // Then try with each extension\n    for (const ext of extensions) {\n      tsResolved = matchPath(importPath + ext);\n      if (tsResolved && fs.existsSync(tsResolved)) {\n        result = tsResolved;\n        resolveImportPathCache.set(cacheKey, result);\n        return result;\n      }\n\n      // Also try the resolved path with extension\n      tsResolved = matchPath(importPath);\n      if (tsResolved) {\n        const resolvedWithExt = tsResolved + ext;\n        if (fs.existsSync(resolvedWithExt)) {\n          result = resolvedWithExt;\n          resolveImportPathCache.set(cacheKey, result);\n          return result;\n        }\n      }\n    }\n  }\n\n  // 2. Try enhanced-resolve (handles package.json exports field and modern resolution)\n  try {\n    const resolver = ResolverFactory.createResolver({\n      useSyncFileSystemCalls: true,\n      fileSystem: fs as unknown as FileSystem,\n      extensions,\n      // Include 'development' condition to resolve to source files in monorepos\n      conditionNames: parsingOptions.conditionNames, // defaults to ['browser', 'module', 'import', 'require', 'default']. See generateSettings.ts for more details\n      exportsFields: ['exports'],\n      mainFields,\n    });\n\n    const resolved = resolver.resolveSync({}, basedir, importPath);\n    if (resolved) {\n      result = resolved;\n      resolveImportPathCache.set(cacheKey, result);\n      return result;\n    }\n  } catch {\n    // Fall through to next resolution strategy\n  }\n\n  // 3. Fallback to Node.js resolution (handles relative paths and node_modules)\n  try {\n    result = resolve.sync(importPath, { basedir, extensions });\n    resolveImportPathCache.set(cacheKey, result);\n    return result;\n  } catch {\n    // If resolution fails, try to manually replace .js/.jsx with .ts/.tsx for source files\n    if (importPath.endsWith('.js')) {\n      const tsPath = importPath.replace(/\\.js$/, '.ts');\n      try {\n        result = resolve.sync(tsPath, { basedir, extensions });\n        resolveImportPathCache.set(cacheKey, result);\n        return result;\n      } catch {\n        // Continue to return null\n      }\n    } else if (importPath.endsWith('.jsx')) {\n      const tsxPath = importPath.replace(/\\.jsx$/, '.tsx');\n      try {\n        result = resolve.sync(tsxPath, { basedir, extensions });\n        resolveImportPathCache.set(cacheKey, result);\n        return result;\n      } catch {\n        // Continue to return null\n      }\n    }\n    resolveImportPathCache.set(cacheKey, null);\n    return null;\n  }\n}\n"],"mappings":";;;;;;AAOA,MAAM,EAAE,oBAAoB;;;;;;;;;;AAW5B,SAAgB,kBACd,aACA,YACA,gBACA,wBACe;CAEf,MAAM,WAAW,GAAG,YAAY,IAAI;AACpC,KAAI,uBAAuB,IAAI,SAAS,CACtC,QAAO,uBAAuB,IAAI,SAAS;CAG7C,MAAM,UAAU,KAAK,QAAQ,YAAY;CACzC,MAAM,aAAa;EAAC;EAAQ;EAAO;EAAQ;EAAM;CACjD,MAAM,aAAa,CAAC,UAAU,OAAO;CAErC,IAAI,SAAwB;CAG5B,MAAM,iBAAiB,WAAW,QAAQ;AAC1C,KAAI,eAAe,eAAe,WAAW;EAC3C,MAAM,YAAY,gBAChB,eAAe,iBACf,eAAe,OACf,WACD;EAGD,IAAI,aAAa,UAAU,WAAW;AACtC,MAAI,cAAc,GAAG,WAAW,WAAW,EAAE;AAC3C,YAAS;AACT,0BAAuB,IAAI,UAAU,OAAO;AAC5C,UAAO;;AAIT,OAAK,MAAM,OAAO,YAAY;AAC5B,gBAAa,UAAU,aAAa,IAAI;AACxC,OAAI,cAAc,GAAG,WAAW,WAAW,EAAE;AAC3C,aAAS;AACT,2BAAuB,IAAI,UAAU,OAAO;AAC5C,WAAO;;AAIT,gBAAa,UAAU,WAAW;AAClC,OAAI,YAAY;IACd,MAAM,kBAAkB,aAAa;AACrC,QAAI,GAAG,WAAW,gBAAgB,EAAE;AAClC,cAAS;AACT,4BAAuB,IAAI,UAAU,OAAO;AAC5C,YAAO;;;;;AAOf,KAAI;EAWF,MAAM,WAVW,gBAAgB,eAAe;GAC9C,wBAAwB;GACxB,YAAY;GACZ;GAEA,gBAAgB,eAAe;GAC/B,eAAe,CAAC,UAAU;GAC1B;GACD,CAEwB,CAAC,YAAY,EAAE,EAAE,SAAS,WAAW;AAC9D,MAAI,UAAU;AACZ,YAAS;AACT,0BAAuB,IAAI,UAAU,OAAO;AAC5C,UAAO;;SAEH;AAKR,KAAI;AACF,WAAS,QAAQ,KAAK,YAAY;GAAE;GAAS;GAAY,CAAC;AAC1D,yBAAuB,IAAI,UAAU,OAAO;AAC5C,SAAO;SACD;AAEN,MAAI,WAAW,SAAS,MAAM,EAAE;GAC9B,MAAM,SAAS,WAAW,QAAQ,SAAS,MAAM;AACjD,OAAI;AACF,aAAS,QAAQ,KAAK,QAAQ;KAAE;KAAS;KAAY,CAAC;AACtD,2BAAuB,IAAI,UAAU,OAAO;AAC5C,WAAO;WACD;aAGC,WAAW,SAAS,OAAO,EAAE;GACtC,MAAM,UAAU,WAAW,QAAQ,UAAU,OAAO;AACpD,OAAI;AACF,aAAS,QAAQ,KAAK,SAAS;KAAE;KAAS;KAAY,CAAC;AACvD,2BAAuB,IAAI,UAAU,OAAO;AAC5C,WAAO;WACD;;AAIV,yBAAuB,IAAI,UAAU,KAAK;AAC1C,SAAO"}

package/dist/react/jsx/utils/stringParsing/derivation/containsDeriveCall.js

@@ -1,26 +1,20 @@
-import * as t from '@babel/types';
-import { GT_DERIVE_STRING_FUNCTIONS } from '../../constants.js';
+import { GT_DERIVE_STRING_FUNCTIONS } from "../../constants.js";
+import * as t from "@babel/types";
+//#region src/react/jsx/utils/stringParsing/derivation/containsDeriveCall.ts
 /**
- * Lightweight name-based check for whether an expression tree contains
- * a derive()/declareStatic() call. Does NOT validate imports or scope —
- * used as a fast gate before full resolution via handleDerivation().
- */
-export function containsDeriveCall(expr) {
-    if (t.isCallExpression(expr) && t.isIdentifier(expr.callee)) {
-        return GT_DERIVE_STRING_FUNCTIONS.includes(expr.callee.name);
-    }
-    if (t.isBinaryExpression(expr)) {
-        return ((t.isExpression(expr.left) && containsDeriveCall(expr.left)) ||
-            (t.isExpression(expr.right) && containsDeriveCall(expr.right)));
-    }
-    if (t.isTemplateLiteral(expr)) {
-        return expr.expressions.some((e) => t.isExpression(e) && containsDeriveCall(e));
-    }
-    if (t.isConditionalExpression(expr)) {
-        return (containsDeriveCall(expr.consequent) || containsDeriveCall(expr.alternate));
-    }
-    if (t.isParenthesizedExpression(expr)) {
-        return containsDeriveCall(expr.expression);
-    }
-    return false;
+* Lightweight name-based check for whether an expression tree contains
+* a derive()/declareStatic() call. Does NOT validate imports or scope —
+* used as a fast gate before full resolution via handleDerivation().
+*/
+function containsDeriveCall(expr) {
+	if (t.isCallExpression(expr) && t.isIdentifier(expr.callee)) return GT_DERIVE_STRING_FUNCTIONS.includes(expr.callee.name);
+	if (t.isBinaryExpression(expr)) return t.isExpression(expr.left) && containsDeriveCall(expr.left) || t.isExpression(expr.right) && containsDeriveCall(expr.right);
+	if (t.isTemplateLiteral(expr)) return expr.expressions.some((e) => t.isExpression(e) && containsDeriveCall(e));
+	if (t.isConditionalExpression(expr)) return containsDeriveCall(expr.consequent) || containsDeriveCall(expr.alternate);
+	if (t.isParenthesizedExpression(expr)) return containsDeriveCall(expr.expression);
+	return false;
 }
+//#endregion
+export { containsDeriveCall };
+
+//# sourceMappingURL=containsDeriveCall.js.map

package/dist/react/jsx/utils/stringParsing/derivation/containsDeriveCall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"containsDeriveCall.js","names":[],"sources":["../../../../../../src/react/jsx/utils/stringParsing/derivation/containsDeriveCall.ts"],"sourcesContent":["import * as t from '@babel/types';\nimport { GT_DERIVE_STRING_FUNCTIONS } from '../../constants.js';\n\n/**\n * Lightweight name-based check for whether an expression tree contains\n * a derive()/declareStatic() call. Does NOT validate imports or scope —\n * used as a fast gate before full resolution via handleDerivation().\n */\nexport function containsDeriveCall(expr: t.Expression): boolean {\n  if (t.isCallExpression(expr) && t.isIdentifier(expr.callee)) {\n    return GT_DERIVE_STRING_FUNCTIONS.includes(\n      expr.callee.name as (typeof GT_DERIVE_STRING_FUNCTIONS)[number]\n    );\n  }\n  if (t.isBinaryExpression(expr)) {\n    return (\n      (t.isExpression(expr.left) && containsDeriveCall(expr.left)) ||\n      (t.isExpression(expr.right) && containsDeriveCall(expr.right))\n    );\n  }\n  if (t.isTemplateLiteral(expr)) {\n    return expr.expressions.some(\n      (e) => t.isExpression(e) && containsDeriveCall(e)\n    );\n  }\n  if (t.isConditionalExpression(expr)) {\n    return (\n      containsDeriveCall(expr.consequent) || containsDeriveCall(expr.alternate)\n    );\n  }\n  if (t.isParenthesizedExpression(expr)) {\n    return containsDeriveCall(expr.expression);\n  }\n  return false;\n}\n"],"mappings":";;;;;;;;AAQA,SAAgB,mBAAmB,MAA6B;AAC9D,KAAI,EAAE,iBAAiB,KAAK,IAAI,EAAE,aAAa,KAAK,OAAO,CACzD,QAAO,2BAA2B,SAChC,KAAK,OAAO,KACb;AAEH,KAAI,EAAE,mBAAmB,KAAK,CAC5B,QACG,EAAE,aAAa,KAAK,KAAK,IAAI,mBAAmB,KAAK,KAAK,IAC1D,EAAE,aAAa,KAAK,MAAM,IAAI,mBAAmB,KAAK,MAAM;AAGjE,KAAI,EAAE,kBAAkB,KAAK,CAC3B,QAAO,KAAK,YAAY,MACrB,MAAM,EAAE,aAAa,EAAE,IAAI,mBAAmB,EAAE,CAClD;AAEH,KAAI,EAAE,wBAAwB,KAAK,CACjC,QACE,mBAAmB,KAAK,WAAW,IAAI,mBAAmB,KAAK,UAAU;AAG7E,KAAI,EAAE,0BAA0B,KAAK,CACnC,QAAO,mBAAmB,KAAK,WAAW;AAE5C,QAAO"}