gt 2.14.35 → 2.14.36

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleDerivation.js","names":[],"sources":["../../../../../../src/react/jsx/utils/stringParsing/derivation/handleDerivation.ts"],"sourcesContent":["import * as t from '@babel/types';\nimport { NodePath } from '@babel/traverse';\nimport { ParsingConfigOptions } from '../../../../../types/parsing.js';\nimport { parseStringExpression, nodeToStrings } from '../../parseString.js';\nimport { StringNode } from '../../types.js';\nimport { buildImportMap } from '../../buildImportMap.js';\nimport { resolveImportPath } from '../../resolveImportPath.js';\nimport { parse } from '@babel/parser';\nimport fs from 'node:fs';\nimport {\n  warnFunctionNotFoundSync,\n  warnDeriveFunctionNoResultsSync,\n  warnDeriveFunctionNotWrappedSync,\n  warnAutoderiveNoResultsSync,\n} from '../../../../../console/index.js';\n\nimport traverseModule from '@babel/traverse';\nimport generateModule from '@babel/generator';\nimport { isDeriveCall } from './isDeriveCall.js';\n// Handle CommonJS/ESM interop\nconst traverse = traverseModule.default || traverseModule;\nconst generate = generateModule.default || generateModule;\n\n// Nested arrays of strings (deprecated - kept for backwards compatibility)\nexport type StringTree = (string | StringTree)[];\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}`\n * Value: Node result or null\n */\nconst processFunctionCache = new Map<string, StringNode | null>();\n\n/**\n * Extracts content if an expression is derivable (statically analyzable) or uses derive()\n * Returns a Node representing the parsed expression\n * @param expr - The expression to check\n * @param tPath - NodePath for scope resolution\n * @param file - Current file path\n * @param parsingOptions - Parsing configuration\n * @param errors - Errors to add to\n * @param runtimeInterpolationState - When provided, non-derive dynamic expressions become {n} placeholders instead of errors. Pass { index: 0 } at the entry point for template macros.\n * @param skipDeriveInvocation - If true, skip derive invocation check\n * @returns Node | null - The parsed node, or null if invalid\n *\n * @note runtimeInterpolationState\n *  - Only provide at entry for template macros, otherwise omit\n *  - t`Hello {nonDerivableValue}` -> t`Hello {0}`\n *\n */\nexport function handleDerivation({\n  expr,\n  tPath,\n  file,\n  parsingOptions,\n  errors,\n  warnings,\n  runtimeInterpolationState,\n  skipDeriveInvocation,\n}: {\n  expr: t.Expression;\n  tPath: NodePath;\n  file: string;\n  parsingOptions: ParsingConfigOptions;\n  errors: string[];\n  warnings: Set<string>;\n  runtimeInterpolationState?: { index: number };\n  skipDeriveInvocation?: boolean;\n}): StringNode | null {\n  if (!expr) {\n    return null;\n  }\n\n  // Handle expressions\n  if (t.isCallExpression(expr)) {\n    if (isDeriveCall({ expr, tPath })) {\n      const variants = getDeriveVariants({\n        call: expr,\n        tPath,\n        file,\n        parsingOptions,\n        errors,\n        warnings,\n      });\n      if (variants) {\n        return {\n          type: 'choice',\n          nodes: variants.map((v) => ({ type: 'text', text: v })),\n        };\n      }\n      // derive() had no resolvable results\n      const code =\n        expr.arguments.length > 0\n          ? generate(expr.arguments[0]).code\n          : 'no arguments';\n      errors.push(\n        warnDeriveFunctionNoResultsSync(\n          file,\n          code,\n          `${expr.loc?.start?.line}:${expr.loc?.start?.column}`\n        )\n      );\n      return null;\n    }\n    // Non-derive call\n    if (runtimeInterpolationState) {\n      return { type: 'text', text: `{${runtimeInterpolationState.index++}}` };\n    }\n    const calleeName = t.isIdentifier(expr.callee)\n      ? expr.callee.name\n      : generate(expr.callee).code;\n    errors.push(\n      warnDeriveFunctionNotWrappedSync(\n        file,\n        calleeName,\n        `${expr.callee.loc?.start?.line}:${expr.callee.loc?.start?.column}`\n      )\n    );\n    return null;\n  }\n\n  // Handle direct string literals\n  if (t.isStringLiteral(expr)) {\n    return { type: 'text', text: expr.value };\n  }\n\n  // Handle template literals\n  if (t.isTemplateLiteral(expr)) {\n    const parts: StringNode[] = [];\n    for (let index = 0; index < expr.quasis.length; index++) {\n      const quasi = expr.quasis[index];\n      const text = quasi.value.cooked ?? quasi.value.raw ?? '';\n      if (text) {\n        parts.push({ type: 'text', text });\n      }\n      const exprNode = expr.expressions[index];\n      if (exprNode && t.isExpression(exprNode)) {\n        if (isDeriveCall({ expr: exprNode, tPath })) {\n          // Derive — resolve fully (no runtime interpolation forwarding)\n          const result = handleDerivation({\n            expr: exprNode,\n            tPath,\n            file,\n            parsingOptions,\n            errors,\n            warnings,\n          });\n          if (result === null) return null;\n          parts.push(result);\n        } else {\n          // Non-derive — recurse with runtime interpolation forwarded\n          const result = handleDerivation({\n            expr: exprNode,\n            tPath,\n            file,\n            parsingOptions,\n            errors,\n            warnings,\n            runtimeInterpolationState,\n            skipDeriveInvocation,\n          });\n          if (result === null) return null;\n          parts.push(result);\n        }\n      }\n    }\n\n    if (parts.length === 0) {\n      return { type: 'text', text: '' };\n    }\n    if (parts.length === 1) {\n      return parts[0];\n    }\n    return { type: 'sequence', nodes: parts };\n  }\n\n  // Handle binary expressions\n  if (t.isBinaryExpression(expr) && expr.operator === '+') {\n    if (!t.isExpression(expr.left) || !t.isExpression(expr.right)) {\n      return null;\n    }\n    const leftResult = handleDerivation({\n      expr: expr.left,\n      tPath,\n      file,\n      parsingOptions,\n      errors,\n      warnings,\n      runtimeInterpolationState,\n      skipDeriveInvocation,\n    });\n    const rightResult = handleDerivation({\n      expr: expr.right,\n      tPath,\n      file,\n      parsingOptions,\n      errors,\n      warnings,\n      runtimeInterpolationState,\n      skipDeriveInvocation,\n    });\n\n    if (leftResult === null || rightResult === null) {\n      return null;\n    }\n\n    return { type: 'sequence', nodes: [leftResult, rightResult] };\n  }\n\n  // Handle parenthesized expressions\n  if (t.isParenthesizedExpression(expr)) {\n    return handleDerivation({\n      expr: expr.expression,\n      tPath,\n      file,\n      parsingOptions,\n      errors,\n      warnings,\n      runtimeInterpolationState,\n      skipDeriveInvocation,\n    });\n  }\n\n  // Handle numeric literals by converting them to strings\n  if (t.isNumericLiteral(expr)) {\n    return { type: 'text', text: String(expr.value) };\n  }\n\n  // Handle unary expressions by converting them to strings\n  if (t.isUnaryExpression(expr)) {\n    let operator = '';\n    if (expr.operator === '-') {\n      operator = expr.operator;\n    }\n    if (t.isNumericLiteral(expr.argument)) {\n      if (expr.argument.value === 0) {\n        return { type: 'text', text: '0' };\n      } else {\n        return {\n          type: 'text',\n          text: operator + expr.argument.value.toString(),\n        };\n      }\n    } else {\n      // invalid\n      return null;\n    }\n  }\n\n  // Handle boolean literals by converting them to strings\n  if (t.isBooleanLiteral(expr)) {\n    return { type: 'text', text: String(expr.value) };\n  }\n\n  // Handle null literal\n  if (t.isNullLiteral(expr)) {\n    return { type: 'text', text: 'null' };\n  }\n\n  // Non-static expression\n  if (skipDeriveInvocation) {\n    // Skip pass a `derive()` invocation to do derivation\n    const variants = resolveCallStringVariants(\n      expr,\n      tPath,\n      file,\n      parsingOptions,\n      errors,\n      warnings\n    );\n    if (variants) {\n      return {\n        type: 'choice',\n        nodes: variants.map((v) => ({ type: 'text', text: v })),\n      };\n    }\n    // Autoderive had no resolvable results\n    const code = generate(expr).code;\n    errors.push(\n      warnAutoderiveNoResultsSync(\n        file,\n        code,\n        `${expr.loc?.start?.line}:${expr.loc?.start?.column}`\n      )\n    );\n    return null;\n  }\n\n  // Not a derivable expression\n  if (runtimeInterpolationState) {\n    return { type: 'text', text: `{${runtimeInterpolationState.index++}}` };\n  }\n  return null;\n}\n\n/**\n * Given a CallExpression, if it is derive(<call>) or derive(await <call>),\n * return all possible string outcomes of that argument call as an array of strings.\n *\n * Examples:\n *   derive(time()) -> [\"day\", \"night\"]\n *   derive(await time()) -> [\"day\", \"night\"]\n *\n * Returns null if it can't be resolved.\n */\nfunction getDeriveVariants<T extends t.CallExpression = t.CallExpression>({\n  call,\n  tPath,\n  file,\n  parsingOptions,\n  errors,\n  warnings,\n}: {\n  call: T;\n  tPath: NodePath;\n  file: string;\n  parsingOptions: ParsingConfigOptions;\n  errors: string[];\n  warnings: Set<string>;\n}): string[] | null {\n  // --- Validate Callee --- //\n\n  // Must be a derive(...) call or an alias of it\n  if (!isDeriveCall({ expr: call, tPath })) {\n    const calleeName = t.isIdentifier(call.callee)\n      ? call.callee.name\n      : generate(call.callee).code;\n    errors.push(\n      warnDeriveFunctionNotWrappedSync(\n        file,\n        calleeName,\n        `${call.callee.loc?.start?.line}:${call.callee.loc?.start?.column}`\n      )\n    );\n    return null;\n  }\n\n  // --- Validate Arguments --- //\n\n  if (call.arguments.length !== 1) return null;\n\n  const arg = call.arguments[0];\n  if (!t.isExpression(arg)) return null;\n\n  // Handle await expression: derive(await time())\n  if (t.isAwaitExpression(arg)) {\n    // Resolve the inner call's possible string outcomes\n    return resolveCallStringVariants(\n      arg.argument,\n      tPath,\n      file,\n      parsingOptions,\n      errors,\n      warnings\n    );\n  }\n  // Handle call expression: derive(time())\n  if (t.isCallExpression(arg)) {\n    return resolveCallStringVariants(\n      arg,\n      tPath,\n      file,\n      parsingOptions,\n      errors,\n      warnings\n    );\n  }\n  // Handle other expressions (ternary, string literal, etc.) by recursing into handleDerivation\n  const node = handleDerivation({\n    expr: arg,\n    tPath,\n    file,\n    parsingOptions,\n    errors,\n    warnings,\n    skipDeriveInvocation: true,\n  });\n  if (node) {\n    return nodeToStrings(node);\n  }\n  return null;\n}\n\nfunction resolveCallStringVariants(\n  expression: t.Expression,\n  tPath: NodePath,\n  file: string,\n  parsingOptions: ParsingConfigOptions,\n  errors: string[],\n  warnings: Set<string>\n): string[] | null {\n  // Handle function identifier calls: derive(time())\n  if (t.isCallExpression(expression) && t.isIdentifier(expression.callee)) {\n    const functionName = expression.callee.name;\n\n    // Use Binding to resolve the function\n    const calleeBinding = tPath.scope.getBinding(functionName);\n\n    if (calleeBinding) {\n      // Check if the binding itself is an import (not just if the name exists in imports)\n      const isImportBinding =\n        calleeBinding.path.isImportSpecifier() ||\n        calleeBinding.path.isImportDefaultSpecifier() ||\n        calleeBinding.path.isImportNamespaceSpecifier();\n\n      if (isImportBinding) {\n        // Function is imported - resolve cross-file\n        const importedFunctionsMap = buildImportMap(\n          tPath.scope.getProgramParent().path\n        );\n\n        let originalName: string | undefined;\n        if (calleeBinding.path.isImportSpecifier()) {\n          originalName = t.isIdentifier(calleeBinding.path.node.imported)\n            ? calleeBinding.path.node.imported.name\n            : calleeBinding.path.node.imported.value;\n        } else if (calleeBinding.path.isImportDefaultSpecifier()) {\n          originalName = calleeBinding.path.node.local.name;\n        } else if (calleeBinding.path.isImportNamespaceSpecifier()) {\n          originalName = calleeBinding.path.node.local.name;\n        }\n\n        const importPath = importedFunctionsMap.get(functionName);\n        if (importPath) {\n          const filePath = resolveImportPath(\n            file,\n            importPath,\n            parsingOptions,\n            resolveImportPathCache\n          );\n\n          if (filePath && originalName) {\n            const node = resolveFunctionInFile(\n              filePath,\n              originalName,\n              parsingOptions,\n              errors,\n              warnings\n            );\n            if (node) {\n              return nodeToStrings(node);\n            }\n          }\n        }\n      } else {\n        // Function is local - use parseStringExpression with resolveFunctionCall\n        const node = resolveFunctionCallFromBinding(\n          calleeBinding,\n          tPath,\n          file,\n          parsingOptions,\n          warnings,\n          errors\n        );\n        if (node) {\n          return nodeToStrings(node);\n        }\n      }\n    } else {\n      // Function not found in scope\n      errors.push(\n        warnFunctionNotFoundSync(\n          file,\n          functionName,\n          `${expression.callee.loc?.start?.line}:${expression.callee.loc?.start?.column}`\n        )\n      );\n      return null;\n    }\n  }\n\n  // If we get here: analyze this call as derivable (statically analyzable)\n  const node = parseStringExpression(\n    expression,\n    tPath,\n    file,\n    parsingOptions,\n    warnings,\n    errors\n  );\n  if (node) {\n    return nodeToStrings(node);\n  }\n  return null;\n}\n\n/**\n * Resolves a function from a binding (local function) using parseStringExpression logic\n */\nfunction resolveFunctionCallFromBinding(\n  calleeBinding: ReturnType<NodePath['scope']['getBinding']>,\n  tPath: NodePath,\n  file: string,\n  parsingOptions: ParsingConfigOptions,\n  warnings: Set<string>,\n  errors: string[]\n): StringNode | null {\n  if (!calleeBinding) {\n    return null;\n  }\n\n  const bindingPath = calleeBinding.path;\n  const branches: StringNode[] = [];\n\n  // Handle function declarations: function time() { return \"day\"; }\n  if (bindingPath.isFunctionDeclaration()) {\n    bindingPath.traverse({\n      ReturnStatement(returnPath) {\n        // Only process return statements that are direct children of this function\n        const parentFunction = returnPath.getFunctionParent();\n        if (parentFunction?.node !== bindingPath.node) {\n          return;\n        }\n\n        const returnArg = returnPath.node.argument;\n        if (!returnArg || !t.isExpression(returnArg)) {\n          return;\n        }\n        const returnResult = parseStringExpression(\n          returnArg,\n          returnPath,\n          file,\n          parsingOptions,\n          warnings,\n          errors\n        );\n        if (returnResult !== null) {\n          branches.push(returnResult);\n        }\n      },\n    });\n  }\n  // Handle arrow functions: const time = () => \"day\"\n  else if (bindingPath.isVariableDeclarator()) {\n    const init = bindingPath.get('init');\n    if (!init.isArrowFunctionExpression()) {\n      return null;\n    }\n\n    const body = init.get('body');\n\n    // Handle expression body: () => \"day\"\n    if (body.isExpression()) {\n      const bodyResult = parseStringExpression(\n        body.node,\n        body,\n        file,\n        parsingOptions,\n        warnings,\n        errors\n      );\n      if (bodyResult !== null) {\n        branches.push(bodyResult);\n      }\n    }\n    // Handle block body: () => { return \"day\"; }\n    else if (body.isBlockStatement()) {\n      const arrowFunction = init.node;\n      body.traverse({\n        ReturnStatement(returnPath) {\n          // Only process return statements that are direct children of this function\n          const parentFunction = returnPath.getFunctionParent();\n          if (parentFunction?.node !== arrowFunction) {\n            return;\n          }\n\n          const returnArg = returnPath.node.argument;\n          if (!returnArg || !t.isExpression(returnArg)) {\n            return;\n          }\n          const returnResult = parseStringExpression(\n            returnArg,\n            returnPath,\n            file,\n            parsingOptions,\n            warnings,\n            errors\n          );\n          if (returnResult !== null) {\n            branches.push(returnResult);\n          }\n        },\n      });\n    }\n  }\n\n  if (branches.length === 0) {\n    return null;\n  }\n\n  if (branches.length === 1) {\n    return branches[0];\n  }\n\n  return { type: 'choice', nodes: branches };\n}\n\n/**\n * Resolves a function definition in an external file\n */\nfunction resolveFunctionInFile(\n  filePath: string,\n  functionName: string,\n  parsingOptions: ParsingConfigOptions,\n  errors: string[],\n  warnings: Set<string>\n): StringNode | null {\n  // Check cache first\n  const cacheKey = `${filePath}::${functionName}`;\n  if (processFunctionCache.has(cacheKey)) {\n    return processFunctionCache.get(cacheKey) ?? null;\n  }\n\n  let result: StringNode | null = null;\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    traverse(ast, {\n      // Handle re-exports: export * from './utils'\n      ExportAllDeclaration(path) {\n        // Only follow re-exports if we haven't found the function yet\n        if (result !== null) return;\n\n        if (t.isStringLiteral(path.node.source)) {\n          const reexportPath = path.node.source.value;\n          const resolvedPath = resolveImportPath(\n            filePath,\n            reexportPath,\n            parsingOptions,\n            resolveImportPathCache\n          );\n\n          if (resolvedPath) {\n            // Recursively resolve in the re-exported file\n            const reexportResult = resolveFunctionInFile(\n              resolvedPath,\n              functionName,\n              parsingOptions,\n              errors,\n              warnings\n            );\n            if (reexportResult) {\n              result = reexportResult;\n            }\n          }\n        }\n      },\n      // Handle named re-exports: export { fn1 } from './utils'\n      ExportNamedDeclaration(path) {\n        // Only follow re-exports if we haven't found the function yet\n        if (result !== null) return;\n\n        // Check if this is a re-export with a source\n        if (path.node.source && t.isStringLiteral(path.node.source)) {\n          // Check if any of the exported specifiers match our function name\n          const hasMatchingExport = 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\n          if (hasMatchingExport) {\n            const reexportPath = path.node.source.value;\n            const resolvedPath = resolveImportPath(\n              filePath,\n              reexportPath,\n              parsingOptions,\n              resolveImportPathCache\n            );\n\n            if (resolvedPath) {\n              // Find the original name in case it was renamed\n              const specifier = path.node.specifiers.find((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\n              let originalName = functionName;\n              if (\n                specifier &&\n                t.isExportSpecifier(specifier) &&\n                t.isIdentifier(specifier.local)\n              ) {\n                originalName = specifier.local.name;\n              }\n\n              // Recursively resolve in the re-exported file\n              const reexportResult = resolveFunctionInFile(\n                resolvedPath,\n                originalName,\n                parsingOptions,\n                errors,\n                warnings\n              );\n              if (reexportResult) {\n                result = reexportResult;\n              }\n            }\n          }\n        }\n      },\n      // Handle function declarations: function woah() { ... }\n      FunctionDeclaration(path) {\n        if (path.node.id?.name === functionName && result === null) {\n          const branches: StringNode[] = [];\n          path.traverse({\n            Function(innerPath) {\n              // Skip nested functions\n              innerPath.skip();\n            },\n            ReturnStatement(returnPath: NodePath) {\n              if (!t.isReturnStatement(returnPath.node)) {\n                return;\n              }\n              const returnArg = returnPath.node.argument;\n              if (!returnArg || !t.isExpression(returnArg)) {\n                return;\n              }\n              const returnResult = parseStringExpression(\n                returnArg,\n                returnPath,\n                filePath,\n                parsingOptions,\n                warnings,\n                errors\n              );\n              if (returnResult !== null) {\n                branches.push(returnResult);\n              }\n            },\n          });\n\n          if (branches.length === 1) {\n            result = branches[0];\n          } else if (branches.length > 1) {\n            result = { type: 'choice', nodes: branches };\n          }\n        }\n      },\n      // Handle variable declarations: const woah = () => { ... }\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          result === null\n        ) {\n          const init = path.get('init');\n          if (\n            !init.isArrowFunctionExpression() &&\n            !init.isFunctionExpression()\n          ) {\n            return;\n          }\n\n          const bodyPath = init.get('body');\n          const branches: StringNode[] = [];\n\n          // Handle expression body: () => \"day\"\n          if (!Array.isArray(bodyPath) && t.isExpression(bodyPath.node)) {\n            const bodyResult = parseStringExpression(\n              bodyPath.node,\n              bodyPath,\n              filePath,\n              parsingOptions,\n              warnings,\n              errors\n            );\n            if (bodyResult !== null) {\n              branches.push(bodyResult);\n            }\n          }\n          // Handle block body: () => { return \"day\"; }\n          else if (\n            !Array.isArray(bodyPath) &&\n            t.isBlockStatement(bodyPath.node)\n          ) {\n            const arrowFunction = init.node;\n            bodyPath.traverse({\n              Function(innerPath: NodePath) {\n                // Skip nested functions\n                innerPath.skip();\n              },\n              ReturnStatement(returnPath: NodePath) {\n                // Only process return statements that are direct children of this function\n                const parentFunction = returnPath.getFunctionParent();\n                if (parentFunction?.node !== arrowFunction) {\n                  return;\n                }\n\n                if (!t.isReturnStatement(returnPath.node)) {\n                  return;\n                }\n                const returnArg = returnPath.node.argument;\n                if (!returnArg || !t.isExpression(returnArg)) {\n                  return;\n                }\n                const returnResult = parseStringExpression(\n                  returnArg,\n                  returnPath,\n                  filePath,\n                  parsingOptions,\n                  warnings,\n                  errors\n                );\n                if (returnResult !== null) {\n                  branches.push(returnResult);\n                }\n              },\n            });\n          }\n\n          if (branches.length === 1) {\n            result = branches[0];\n          } else if (branches.length > 1) {\n            result = { type: 'choice', nodes: branches };\n          }\n        }\n      },\n    });\n  } catch (error) {\n    // File read or parse error - return null\n    errors.push(\n      warnDeriveFunctionNoResultsSync(\n        filePath,\n        functionName,\n        'file read/parse error: ' + error\n      )\n    );\n    result = null;\n  }\n\n  // Cache the result\n  processFunctionCache.set(cacheKey, result);\n  return result;\n}\n"],"mappings":"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"}

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

@@ -1,70 +1,60 @@
-import { handleDerivation } from './handleDerivation.js';
-import { warnNonStringSync } from '../../../../../console/index.js';
-import { nodeToStrings } from '../../parseString.js';
-import generateModule from '@babel/generator';
-import { indexVars } from 'generaltranslation/internal';
-import { randomUUID } from 'node:crypto';
-import { isValidIcu } from '../../../evaluateJsx.js';
-import { warnInvalidIcuSync } from '../../../../../console/index.js';
-// Handle CommonJS/ESM interop
+import { isValidIcu } from "../../../evaluateJsx.js";
+import { warnInvalidIcuSync, warnNonStringSync } from "../../../../../console/index.js";
+import { nodeToStrings } from "../../parseString.js";
+import { handleDerivation } from "./handleDerivation.js";
+import { randomUUID } from "node:crypto";
+import generateModule from "@babel/generator";
+import { indexVars } from "generaltranslation/internal";
+//#region src/react/jsx/utils/stringParsing/derivation/index.ts
 const generate = generateModule.default || generateModule;
 /**
- * Registers an expression with support for derive
- * Entry point for string derivation
- *
- * @param tPath - The path to the tag identifier
- * @param expr - The expression to parse
- * @param metadata - Extracted metadata (empty for tagged templates)
- * @param config - Parsing configuration
- * @param output - Parsing output collectors
- * @param enableRuntimeInterpolation - For template macros, enables runtime interpolation for non-derive calls
- */
-export function deriveExpression({ tPath, expr, metadata, config, output, index, enableRuntimeInterpolation = false, contextVariants, }) {
-    // parse derivable expression
-    const stringNode = handleDerivation({
-        expr,
-        tPath,
-        file: config.file,
-        parsingOptions: config.parsingOptions,
-        errors: output.errors,
-        warnings: output.warnings,
-        runtimeInterpolationState: enableRuntimeInterpolation
-            ? { index: 0 }
-            : undefined,
-        skipDeriveInvocation: config.autoderiveMethod === 'ENABLED',
-    });
-    // Nothing returned, push error
-    if (!stringNode) {
-        output.errors.push(warnNonStringSync(config.file, generate(expr).code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
-        return;
-    }
-    // validate ICU
-    const strings = nodeToStrings(stringNode).map(indexVars);
-    if (!config.ignoreInvalidIcu) {
-        for (const string of strings) {
-            const { isValid, error } = isValidIcu(string);
-            if (!isValid) {
-                output.warnings.add(warnInvalidIcuSync(config.file, string, error ?? 'Unknown error', `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
-                return;
-            }
-        }
-    }
-    const temporaryDeriveId = `derive-temp-id-${randomUUID()}`;
-    const contexts = contextVariants ?? [metadata.context];
-    for (const string of strings) {
-        for (const context of contexts) {
-            output.updates.push({
-                dataFormat: (metadata.format || 'ICU'),
-                source: string,
-                metadata: {
-                    ...metadata,
-                    ...(context != null && { context }),
-                    // Add the index if an id and index is provided (for handling when registering an array of strings)
-                    ...(metadata.id &&
-                        index != null && { id: `${metadata.id}.${index}` }),
-                    staticId: temporaryDeriveId,
-                },
-            });
-        }
-    }
+* Registers an expression with support for derive
+* Entry point for string derivation
+*
+* @param tPath - The path to the tag identifier
+* @param expr - The expression to parse
+* @param metadata - Extracted metadata (empty for tagged templates)
+* @param config - Parsing configuration
+* @param output - Parsing output collectors
+* @param enableRuntimeInterpolation - For template macros, enables runtime interpolation for non-derive calls
+*/
+function deriveExpression({ tPath, expr, metadata, config, output, index, enableRuntimeInterpolation = false, contextVariants }) {
+	const stringNode = handleDerivation({
+		expr,
+		tPath,
+		file: config.file,
+		parsingOptions: config.parsingOptions,
+		errors: output.errors,
+		warnings: output.warnings,
+		runtimeInterpolationState: enableRuntimeInterpolation ? { index: 0 } : void 0,
+		skipDeriveInvocation: config.autoderiveMethod === "ENABLED"
+	});
+	if (!stringNode) {
+		output.errors.push(warnNonStringSync(config.file, generate(expr).code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+		return;
+	}
+	const strings = nodeToStrings(stringNode).map(indexVars);
+	if (!config.ignoreInvalidIcu) for (const string of strings) {
+		const { isValid, error } = isValidIcu(string);
+		if (!isValid) {
+			output.warnings.add(warnInvalidIcuSync(config.file, string, error ?? "Unknown error", `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+			return;
+		}
+	}
+	const temporaryDeriveId = `derive-temp-id-${randomUUID()}`;
+	const contexts = contextVariants ?? [metadata.context];
+	for (const string of strings) for (const context of contexts) output.updates.push({
+		dataFormat: metadata.format || "ICU",
+		source: string,
+		metadata: {
+			...metadata,
+			...context != null && { context },
+			...metadata.id && index != null && { id: `${metadata.id}.${index}` },
+			staticId: temporaryDeriveId
+		}
+	});
 }
+//#endregion
+export { deriveExpression };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../../src/react/jsx/utils/stringParsing/derivation/index.ts"],"sourcesContent":["import { NodePath } from '@babel/traverse';\nimport * as t from '@babel/types';\nimport type { DataFormat } from '@generaltranslation/format/types';\nimport { InlineMetadata } from '../processTranslationCall/extractStringEntryMetadata.js';\nimport { ParsingConfig } from '../types.js';\nimport { ParsingOutput } from '../types.js';\nimport { handleDerivation } from './handleDerivation.js';\nimport { warnNonStringSync } from '../../../../../console/index.js';\nimport { nodeToStrings } from '../../parseString.js';\nimport generateModule from '@babel/generator';\nimport { indexVars } from 'generaltranslation/internal';\nimport { randomUUID } from 'node:crypto';\nimport { isValidIcu } from '../../../evaluateJsx.js';\nimport { warnInvalidIcuSync } from '../../../../../console/index.js';\n\n// Handle CommonJS/ESM interop\nconst generate = generateModule.default || generateModule;\n\n/**\n * Registers an expression with support for derive\n * Entry point for string derivation\n *\n * @param tPath - The path to the tag identifier\n * @param expr - The expression to parse\n * @param metadata - Extracted metadata (empty for tagged templates)\n * @param config - Parsing configuration\n * @param output - Parsing output collectors\n * @param enableRuntimeInterpolation - For template macros, enables runtime interpolation for non-derive calls\n */\nexport function deriveExpression({\n  tPath,\n  expr,\n  metadata,\n  config,\n  output,\n  index,\n  enableRuntimeInterpolation = false,\n  contextVariants,\n}: {\n  tPath: NodePath;\n  expr: t.Expression;\n  metadata: InlineMetadata;\n  config: ParsingConfig;\n  output: ParsingOutput;\n  index?: number;\n  enableRuntimeInterpolation?: boolean;\n  contextVariants?: string[];\n}) {\n  // parse derivable expression\n  const stringNode = handleDerivation({\n    expr,\n    tPath,\n    file: config.file,\n    parsingOptions: config.parsingOptions,\n    errors: output.errors,\n    warnings: output.warnings,\n    runtimeInterpolationState: enableRuntimeInterpolation\n      ? { index: 0 }\n      : undefined,\n    skipDeriveInvocation: config.autoderiveMethod === 'ENABLED',\n  });\n\n  // Nothing returned, push error\n  if (!stringNode) {\n    output.errors.push(\n      warnNonStringSync(\n        config.file,\n        generate(expr).code,\n        `${expr.loc?.start?.line}:${expr.loc?.start?.column}`\n      )\n    );\n    return;\n  }\n\n  // validate ICU\n  const strings = nodeToStrings(stringNode).map(indexVars);\n  if (!config.ignoreInvalidIcu) {\n    for (const string of strings) {\n      const { isValid, error } = isValidIcu(string);\n      if (!isValid) {\n        output.warnings.add(\n          warnInvalidIcuSync(\n            config.file,\n            string,\n            error ?? 'Unknown error',\n            `${expr.loc?.start?.line}:${expr.loc?.start?.column}`\n          )\n        );\n        return;\n      }\n    }\n  }\n\n  const temporaryDeriveId = `derive-temp-id-${randomUUID()}`;\n  const contexts = contextVariants ?? [metadata.context];\n  for (const string of strings) {\n    for (const context of contexts) {\n      output.updates.push({\n        dataFormat: (metadata.format || 'ICU') as DataFormat,\n        source: string,\n        metadata: {\n          ...metadata,\n          ...(context != null && { context }),\n          // Add the index if an id and index is provided (for handling when registering an array of strings)\n          ...(metadata.id &&\n            index != null && { id: `${metadata.id}.${index}` }),\n          staticId: temporaryDeriveId,\n        },\n      });\n    }\n  }\n}\n"],"mappings":";;;;;;;;AAgBA,MAAM,WAAW,eAAe,WAAW;;;;;;;;;;;;AAa3C,SAAgB,iBAAiB,EAC/B,OACA,MACA,UACA,QACA,QACA,OACA,6BAA6B,OAC7B,mBAUC;CAED,MAAM,aAAa,iBAAiB;EAClC;EACA;EACA,MAAM,OAAO;EACb,gBAAgB,OAAO;EACvB,QAAQ,OAAO;EACf,UAAU,OAAO;EACjB,2BAA2B,6BACvB,EAAE,OAAO,GAAG,GACZ,KAAA;EACJ,sBAAsB,OAAO,qBAAqB;EACnD,CAAC;AAGF,KAAI,CAAC,YAAY;AACf,SAAO,OAAO,KACZ,kBACE,OAAO,MACP,SAAS,KAAK,CAAC,MACf,GAAG,KAAK,KAAK,OAAO,KAAK,GAAG,KAAK,KAAK,OAAO,SAC9C,CACF;AACD;;CAIF,MAAM,UAAU,cAAc,WAAW,CAAC,IAAI,UAAU;AACxD,KAAI,CAAC,OAAO,iBACV,MAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,EAAE,SAAS,UAAU,WAAW,OAAO;AAC7C,MAAI,CAAC,SAAS;AACZ,UAAO,SAAS,IACd,mBACE,OAAO,MACP,QACA,SAAS,iBACT,GAAG,KAAK,KAAK,OAAO,KAAK,GAAG,KAAK,KAAK,OAAO,SAC9C,CACF;AACD;;;CAKN,MAAM,oBAAoB,kBAAkB,YAAY;CACxD,MAAM,WAAW,mBAAmB,CAAC,SAAS,QAAQ;AACtD,MAAK,MAAM,UAAU,QACnB,MAAK,MAAM,WAAW,SACpB,QAAO,QAAQ,KAAK;EAClB,YAAa,SAAS,UAAU;EAChC,QAAQ;EACR,UAAU;GACR,GAAG;GACH,GAAI,WAAW,QAAQ,EAAE,SAAS;GAElC,GAAI,SAAS,MACX,SAAS,QAAQ,EAAE,IAAI,GAAG,SAAS,GAAG,GAAG,SAAS;GACpD,UAAU;GACX;EACF,CAAC"}

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

@@ -1,38 +1,28 @@
-import * as t from '@babel/types';
-import { GT_DERIVE_STRING_FUNCTIONS } from '../../constants.js';
-import { GT_LIBRARIES } from '../../../../../types/libraries.js';
+import { GT_DERIVE_STRING_FUNCTIONS } from "../../constants.js";
+import { GT_LIBRARIES } from "../../../../../types/libraries.js";
+import * as t from "@babel/types";
+//#region src/react/jsx/utils/stringParsing/derivation/isDeriveCall.ts
 /**
- * Given an expression, determine if it is a derive call
- * @param expr - The expression to check
- * @returns True if the expression is a derive call, false otherwise
- */
-export function isDeriveCall({ expr, tPath, }) {
-    // Check if the expression is a call expression
-    if (!t.isCallExpression(expr))
-        return false;
-    const callee = expr.callee;
-    if (!t.isIdentifier(callee))
-        return false;
-    // Fail if no binding
-    const calleeName = callee.name;
-    const binding = tPath.scope.getBinding(calleeName);
-    if (!binding)
-        return false;
-    // Check if the callee is imported from GT
-    if (!binding.path.isImportSpecifier())
-        return false;
-    const source = binding.path.parentPath?.isImportDeclaration()
-        ? binding.path.parentPath?.node.source.value
-        : undefined;
-    if (!GT_LIBRARIES.includes(source))
-        return false;
-    // Fail if the original name is not 'derive' (or the deprecated 'declareStatic')
-    const imported = binding.path.node.imported;
-    const originalName = t.isIdentifier(imported)
-        ? imported.name
-        : imported.value;
-    if (!GT_DERIVE_STRING_FUNCTIONS.includes(originalName)) {
-        return false;
-    }
-    return true;
+* Given an expression, determine if it is a derive call
+* @param expr - The expression to check
+* @returns True if the expression is a derive call, false otherwise
+*/
+function isDeriveCall({ expr, tPath }) {
+	if (!t.isCallExpression(expr)) return false;
+	const callee = expr.callee;
+	if (!t.isIdentifier(callee)) return false;
+	const calleeName = callee.name;
+	const binding = tPath.scope.getBinding(calleeName);
+	if (!binding) return false;
+	if (!binding.path.isImportSpecifier()) return false;
+	const source = binding.path.parentPath?.isImportDeclaration() ? binding.path.parentPath?.node.source.value : void 0;
+	if (!GT_LIBRARIES.includes(source)) return false;
+	const imported = binding.path.node.imported;
+	const originalName = t.isIdentifier(imported) ? imported.name : imported.value;
+	if (!GT_DERIVE_STRING_FUNCTIONS.includes(originalName)) return false;
+	return true;
 }
+//#endregion
+export { isDeriveCall };
+
+//# sourceMappingURL=isDeriveCall.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isDeriveCall.js","names":[],"sources":["../../../../../../src/react/jsx/utils/stringParsing/derivation/isDeriveCall.ts"],"sourcesContent":["import * as t from '@babel/types';\nimport { NodePath } from '@babel/traverse';\nimport { GT_DERIVE_STRING_FUNCTIONS } from '../../constants.js';\nimport { GT_LIBRARIES, GTLibrary } from '../../../../../types/libraries.js';\n\n/**\n * Given an expression, determine if it is a derive call\n * @param expr - The expression to check\n * @returns True if the expression is a derive call, false otherwise\n */\nexport function isDeriveCall({\n  expr,\n  tPath,\n}: {\n  expr: t.Expression;\n  tPath: NodePath;\n}): boolean {\n  // Check if the expression is a call expression\n  if (!t.isCallExpression(expr)) return false;\n  const callee = expr.callee;\n  if (!t.isIdentifier(callee)) return false;\n\n  // Fail if no binding\n  const calleeName = callee.name;\n  const binding = tPath.scope.getBinding(calleeName);\n  if (!binding) return false;\n\n  // Check if the callee is imported from GT\n  if (!binding.path.isImportSpecifier()) return false;\n  const source = binding.path.parentPath?.isImportDeclaration()\n    ? binding.path.parentPath?.node.source.value\n    : undefined;\n  if (!GT_LIBRARIES.includes(source as GTLibrary)) return false;\n\n  // Fail if the original name is not 'derive' (or the deprecated 'declareStatic')\n  const imported = binding.path.node.imported;\n  const originalName = t.isIdentifier(imported)\n    ? imported.name\n    : imported.value;\n  if (\n    !GT_DERIVE_STRING_FUNCTIONS.includes(\n      originalName as (typeof GT_DERIVE_STRING_FUNCTIONS)[number]\n    )\n  ) {\n    return false;\n  }\n\n  return true;\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,aAAa,EAC3B,MACA,SAIU;AAEV,KAAI,CAAC,EAAE,iBAAiB,KAAK,CAAE,QAAO;CACtC,MAAM,SAAS,KAAK;AACpB,KAAI,CAAC,EAAE,aAAa,OAAO,CAAE,QAAO;CAGpC,MAAM,aAAa,OAAO;CAC1B,MAAM,UAAU,MAAM,MAAM,WAAW,WAAW;AAClD,KAAI,CAAC,QAAS,QAAO;AAGrB,KAAI,CAAC,QAAQ,KAAK,mBAAmB,CAAE,QAAO;CAC9C,MAAM,SAAS,QAAQ,KAAK,YAAY,qBAAqB,GACzD,QAAQ,KAAK,YAAY,KAAK,OAAO,QACrC,KAAA;AACJ,KAAI,CAAC,aAAa,SAAS,OAAoB,CAAE,QAAO;CAGxD,MAAM,WAAW,QAAQ,KAAK,KAAK;CACnC,MAAM,eAAe,EAAE,aAAa,SAAS,GACzC,SAAS,OACT,SAAS;AACb,KACE,CAAC,2BAA2B,SAC1B,aACD,CAED,QAAO;AAGT,QAAO"}

package/dist/react/jsx/utils/stringParsing/processTaggedTemplateCall/handleTaggedTemplateTranslationCall.js

@@ -1,26 +1,31 @@
-import { deriveExpression } from '../derivation/index.js';
+import { deriveExpression } from "../derivation/index.js";
+//#region src/react/jsx/utils/stringParsing/processTaggedTemplateCall/handleTaggedTemplateTranslationCall.ts
 /**
- * Extracts a translatable message from a TaggedTemplateExpression.
- *
- * Follows the same extraction pattern as `extractInterpolatableValues` in
- * `packages/react/src/i18n-context/functions/translation/t.ts`:
- * - Iterates through quasis and expressions interleaved
- * - Creates numeric placeholders ({0}, {1}, etc.) for each expression
- * - Joins all parts into the final source string
- *
- * @param tPath - The path to the tag identifier
- * @param quasi - The TemplateLiteral from the TaggedTemplateExpression
- * @param metadata - Extracted metadata (empty for tagged templates)
- * @param config - Parsing configuration
- * @param output - Parsing output collectors
- */
-export function handleTaggedTemplateTranslationCall({ tPath, quasi, metadata, config, output, }) {
-    deriveExpression({
-        tPath,
-        expr: quasi,
-        metadata,
-        config,
-        output,
-        enableRuntimeInterpolation: true,
-    });
+* Extracts a translatable message from a TaggedTemplateExpression.
+*
+* Follows the same extraction pattern as `extractInterpolatableValues` in
+* `packages/react/src/i18n-context/functions/translation/t.ts`:
+* - Iterates through quasis and expressions interleaved
+* - Creates numeric placeholders ({0}, {1}, etc.) for each expression
+* - Joins all parts into the final source string
+*
+* @param tPath - The path to the tag identifier
+* @param quasi - The TemplateLiteral from the TaggedTemplateExpression
+* @param metadata - Extracted metadata (empty for tagged templates)
+* @param config - Parsing configuration
+* @param output - Parsing output collectors
+*/
+function handleTaggedTemplateTranslationCall({ tPath, quasi, metadata, config, output }) {
+	deriveExpression({
+		tPath,
+		expr: quasi,
+		metadata,
+		config,
+		output,
+		enableRuntimeInterpolation: true
+	});
 }
+//#endregion
+export { handleTaggedTemplateTranslationCall };
+
+//# sourceMappingURL=handleTaggedTemplateTranslationCall.js.map

package/dist/react/jsx/utils/stringParsing/processTaggedTemplateCall/handleTaggedTemplateTranslationCall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleTaggedTemplateTranslationCall.js","names":[],"sources":["../../../../../../src/react/jsx/utils/stringParsing/processTaggedTemplateCall/handleTaggedTemplateTranslationCall.ts"],"sourcesContent":["import * as t from '@babel/types';\nimport { ParsingConfig, ParsingOutput } from '../types.js';\nimport { InlineMetadata } from '../processTranslationCall/extractStringEntryMetadata.js';\nimport { NodePath } from '@babel/traverse';\nimport { deriveExpression } from '../derivation/index.js';\n\n/**\n * Extracts a translatable message from a TaggedTemplateExpression.\n *\n * Follows the same extraction pattern as `extractInterpolatableValues` in\n * `packages/react/src/i18n-context/functions/translation/t.ts`:\n * - Iterates through quasis and expressions interleaved\n * - Creates numeric placeholders ({0}, {1}, etc.) for each expression\n * - Joins all parts into the final source string\n *\n * @param tPath - The path to the tag identifier\n * @param quasi - The TemplateLiteral from the TaggedTemplateExpression\n * @param metadata - Extracted metadata (empty for tagged templates)\n * @param config - Parsing configuration\n * @param output - Parsing output collectors\n */\nexport function handleTaggedTemplateTranslationCall({\n  tPath,\n  quasi,\n  metadata,\n  config,\n  output,\n}: {\n  tPath: NodePath;\n  quasi: t.TemplateLiteral;\n  metadata: InlineMetadata;\n  config: ParsingConfig;\n  output: ParsingOutput;\n}): void {\n  deriveExpression({\n    tPath,\n    expr: quasi,\n    metadata,\n    config,\n    output,\n    enableRuntimeInterpolation: true,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAqBA,SAAgB,oCAAoC,EAClD,OACA,OACA,UACA,QACA,UAOO;AACP,kBAAiB;EACf;EACA,MAAM;EACN;EACA;EACA;EACA,4BAA4B;EAC7B,CAAC"}

package/dist/react/jsx/utils/stringParsing/processTaggedTemplateCall/index.js

@@ -1,34 +1,36 @@
-import * as t from '@babel/types';
-import { handleTaggedTemplateTranslationCall } from './handleTaggedTemplateTranslationCall.js';
-import { extractStringEntryMetadata } from '../processTranslationCall/extractStringEntryMetadata.js';
-import { SURROUNDING_LINE_COUNT } from '../../../../../utils/constants.js';
+import "../../../../../utils/constants.js";
+import { extractStringEntryMetadata } from "../processTranslationCall/extractStringEntryMetadata.js";
+import { handleTaggedTemplateTranslationCall } from "./handleTaggedTemplateTranslationCall.js";
+import * as t from "@babel/types";
+//#region src/react/jsx/utils/stringParsing/processTaggedTemplateCall/index.ts
 /**
- * Processes a tagged template expression (e.g., t`hello ${name}`).
- * Extracts the translatable string with numeric placeholders for expressions.
- *
- * Tagged templates don't support an options argument, but still carry
- * source metadata for dashboard grouping and source context.
- *
- * @param tPath - The path to the tag identifier
- * @param config - Parsing configuration
- * @param output - Parsing output collectors
- */
-export function processTaggedTemplateCall(tPath, config, output) {
-    if (!t.isTaggedTemplateExpression(tPath.parent) ||
-        tPath.parent.tag !== tPath.node) {
-        return;
-    }
-    const metadata = extractStringEntryMetadata({
-        output,
-        config,
-        nodeLoc: tPath.parent.loc,
-        surroundingLineCount: SURROUNDING_LINE_COUNT,
-    });
-    handleTaggedTemplateTranslationCall({
-        tPath,
-        quasi: tPath.parent.quasi,
-        metadata,
-        config,
-        output,
-    });
+* Processes a tagged template expression (e.g., t`hello ${name}`).
+* Extracts the translatable string with numeric placeholders for expressions.
+*
+* Tagged templates don't support an options argument, but still carry
+* source metadata for dashboard grouping and source context.
+*
+* @param tPath - The path to the tag identifier
+* @param config - Parsing configuration
+* @param output - Parsing output collectors
+*/
+function processTaggedTemplateCall(tPath, config, output) {
+	if (!t.isTaggedTemplateExpression(tPath.parent) || tPath.parent.tag !== tPath.node) return;
+	const metadata = extractStringEntryMetadata({
+		output,
+		config,
+		nodeLoc: tPath.parent.loc,
+		surroundingLineCount: 5
+	});
+	handleTaggedTemplateTranslationCall({
+		tPath,
+		quasi: tPath.parent.quasi,
+		metadata,
+		config,
+		output
+	});
 }
+//#endregion
+export { processTaggedTemplateCall };
+
+//# sourceMappingURL=index.js.map

package/dist/react/jsx/utils/stringParsing/processTaggedTemplateCall/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../../src/react/jsx/utils/stringParsing/processTaggedTemplateCall/index.ts"],"sourcesContent":["import { NodePath } from '@babel/traverse';\nimport * as t from '@babel/types';\nimport { ParsingConfig, ParsingOutput } from '../types.js';\nimport { handleTaggedTemplateTranslationCall } from './handleTaggedTemplateTranslationCall.js';\nimport { extractStringEntryMetadata } from '../processTranslationCall/extractStringEntryMetadata.js';\nimport { SURROUNDING_LINE_COUNT } from '../../../../../utils/constants.js';\n\n/**\n * Processes a tagged template expression (e.g., t`hello ${name}`).\n * Extracts the translatable string with numeric placeholders for expressions.\n *\n * Tagged templates don't support an options argument, but still carry\n * source metadata for dashboard grouping and source context.\n *\n * @param tPath - The path to the tag identifier\n * @param config - Parsing configuration\n * @param output - Parsing output collectors\n */\nexport function processTaggedTemplateCall(\n  tPath: NodePath,\n  config: ParsingConfig,\n  output: ParsingOutput\n): void {\n  if (\n    !t.isTaggedTemplateExpression(tPath.parent) ||\n    tPath.parent.tag !== tPath.node\n  ) {\n    return;\n  }\n\n  const metadata = extractStringEntryMetadata({\n    output,\n    config,\n    nodeLoc: tPath.parent.loc,\n    surroundingLineCount: SURROUNDING_LINE_COUNT,\n  });\n\n  handleTaggedTemplateTranslationCall({\n    tPath,\n    quasi: tPath.parent.quasi,\n    metadata,\n    config,\n    output,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,SAAgB,0BACd,OACA,QACA,QACM;AACN,KACE,CAAC,EAAE,2BAA2B,MAAM,OAAO,IAC3C,MAAM,OAAO,QAAQ,MAAM,KAE3B;CAGF,MAAM,WAAW,2BAA2B;EAC1C;EACA;EACA,SAAS,MAAM,OAAO;EACtB,sBAAA;EACD,CAAC;AAEF,qCAAoC;EAClC;EACA,OAAO,MAAM,OAAO;EACpB;EACA;EACA;EACD,CAAC"}