{tCommon('key1')}
\n *\n * // or with pluginOptions.tFunctionNames = [\"myT\"]\n * const { myT: tCommon } = useTranslation('common');\n * return
{tCommon('key1')}
\n *\n * getAliasedTBindingName(nodePath) should return 'tCommon' instead of t or myT\n *\n * @param nodePath: node path to resolve\n * @param tFunctionNames: possible names for the (unaliased) t function\n * @return the resolved t binding name, returning the alias if needed\n */\nfunction getAliasedTBindingName(path, tFunctionNames) {\n const properties = path.get(\"properties\");\n const propertiesArray = Array.isArray(properties) ? properties : [properties];\n for (const property of propertiesArray) {\n if (property.isObjectProperty()) {\n const key = property.node.key;\n const value = property.node.value;\n if (key.type === \"Identifier\" && value.type === \"Identifier\" && tFunctionNames.includes(key.name)) {\n return value.name;\n }\n }\n }\n return tFunctionNames.find(name => path.scope.bindings[name]);\n}\n\n/**\n * Check whether a given JSXElement is a Trans component.\n * @param path: node path to check\n * @returns true if the given element is indeed a `Trans` component.\n */\nfunction isTransComponent(path) {\n const openingElement = path.get(\"openingElement\");\n return referencesImport(openingElement.get(\"name\"), \"react-i18next\", \"Trans\");\n}\n\n/**\n * Given a Trans component, extract its options.\n * @param path The node path of the JSX Element of the trans component\n * @param commentHints Parsed comment hints.\n * @returns The parsed i18next options\n */\nfunction parseTransComponentOptions(path, commentHints) {\n const res = {\n contexts: false,\n hasCount: false,\n keyPrefix: null,\n ns: null,\n defaultValue: null\n };\n const countAttr = findJSXAttributeByName(path, \"count\");\n res.hasCount = countAttr !== null;\n const tOptionsAttr = findJSXAttributeByName(path, \"tOptions\");\n if (tOptionsAttr) {\n const value = tOptionsAttr.get(\"value\");\n if (value.isJSXExpressionContainer()) {\n const expression = value.get(\"expression\");\n if (expression.isObjectExpression()) {\n res.contexts = findKeyInObjectExpression(expression, \"context\") !== null;\n }\n }\n }\n const nsAttr = findJSXAttributeByName(path, \"ns\");\n if (nsAttr) {\n let value = nsAttr.get(\"value\");\n if (value.isJSXExpressionContainer()) value = value.get(\"expression\");\n res.ns = getFirstOrNull(evaluateIfConfident(value));\n }\n const defaultsAttr = findJSXAttributeByName(path, \"defaults\");\n if (defaultsAttr) {\n let value = defaultsAttr.get(\"value\");\n if (value.isJSXExpressionContainer()) value = value.get(\"expression\");\n res.defaultValue = evaluateIfConfident(value);\n }\n return {\n ...res,\n ...parseI18NextOptionsFromCommentHints(path, commentHints)\n };\n}\n\n/**\n * Given the node path of a Trans component, try to extract its key from its\n * attributes.\n * @param path node path of the Trans component.\n * @returns the component key if it was found.\n * @throws ExtractionError if the i18nKey attribute was present but not\n * evaluable.\n */\nfunction parseTransComponentKeyFromAttributes(path) {\n const error = new ExtractionError(`Couldn't evaluate i18next key in Trans component. You should either ` + `make the i18nKey attribute evaluable or skip the line using a skip ` + `comment (/* ${COMMENT_HINTS_KEYWORDS.DISABLE.LINE} */ or /* ` + `${COMMENT_HINTS_KEYWORDS.DISABLE.NEXT_LINE} */).`, path);\n const keyAttribute = findJSXAttributeByName(path, \"i18nKey\");\n if (!keyAttribute) return null;\n const keyAttributeValue = keyAttribute.get(\"value\");\n const keyEvaluation = evaluateIfConfident(keyAttributeValue.isJSXExpressionContainer() ? keyAttributeValue.get(\"expression\") : keyAttributeValue);\n if (typeof keyEvaluation !== \"string\") {\n throw error;\n }\n return keyEvaluation;\n}\n\n/**\n * Check if a JSX element has nested children or if it's a simple text node.\n *\n * Tries to mimic hasChildren function from React i18next:\n * see https://github.com/i18next/react-i18next/blob/8b6caf105/src/Trans.js#L6\n *\n * @param path node path of the JSX element to check\n * @returns whether the node has nested children\n */\nfunction hasChildren(path) {\n const children = path.get(\"children\").filter(path => {\n // Filter out empty JSX expression containers\n // (they do not count, even if they contain comments)\n\n if (path.isJSXExpressionContainer()) {\n const expression = path.get(\"expression\");\n return !expression.isJSXEmptyExpression();\n }\n return true;\n });\n if (children.length === 0) return false;\n if (1 < children.length) return true;\n const child = children[0];\n if (child.isJSXExpressionContainer()) {\n let expression = child.get(\"expression\");\n if (expression.isIdentifier()) {\n const resolvedExpression = resolveIdentifier(expression);\n if (resolvedExpression === null) {\n // We weren't able to resolve the identifier. We consider this as\n // an absence of children, but it isn't very relevant anyways\n // because the extraction is very likely to fail later on.\n return false;\n }\n expression = resolvedExpression;\n }\n\n // If the expression is a string, we have an interpolation like {\"foo\"}\n // The only other valid interpolation would be {{myVar}} but apparently,\n // it is considered as a nested child.\n return typeof evaluateIfConfident(expression) !== \"string\";\n }\n return false;\n}\n\n/**\n * Format the key of a JSX element.\n *\n * @param path node path of the JSX element to format.\n * @param index the current index of the node being parsed.\n * @param config plugin configuration.\n * @returns key corresponding to the JSX element.\n */\nfunction formatJSXElementKey(path, index, config) {\n const openingElement = path.get(\"openingElement\");\n const closingElement = path.get(\"closingElement\");\n let resultTagName = `${index}`; // Tag name we will use in the exported file\n\n const tagName = openingElement.get(\"name\");\n if (openingElement.get(\"attributes\").length === 0 && tagName.isJSXIdentifier() && config.transKeepBasicHtmlNodesFor.includes(tagName.node.name) && !hasChildren(path)) {\n // The tag name should not be transformed to an index\n resultTagName = tagName.node.name;\n if (closingElement.node === null) {\n // opening tag without closing tag (e.g.
)\n return `<${resultTagName}/>`;\n }\n }\n\n // it's nested. let's recurse.\n return `<${resultTagName}>${parseTransComponentKeyFromChildren(path, config)}`;\n}\n\n/**\n * Given the node path of a Trans component, try to extract its key from its\n * children.\n * @param path node path of the Trans component.\n * @returns the component key if it was found.\n * @throws ExtractionError if the extraction did not succeed.\n */\nfunction parseTransComponentKeyFromChildren(path, config) {\n const transComponentExtractionError = new ExtractionError(`Couldn't evaluate i18next key in Trans component. You should either ` + `set the i18nKey attribute to an evaluable value, or make the Trans ` + `component content evaluable or skip the line using a skip comment ` + `(/* ${COMMENT_HINTS_KEYWORDS.DISABLE.LINE} */ or /* ` + `${COMMENT_HINTS_KEYWORDS.DISABLE.NEXT_LINE} */).`, path);\n let children = path.get(\"children\");\n let result = \"\";\n\n // Filter out JSXText nodes that only consist of whitespaces with one or\n // more linefeeds. Such node do not count for the indices.\n children = children.filter(child => {\n return !(child.isJSXText() && child.node.value.trim() === \"\" && child.node.value.includes(\"\\n\"));\n });\n\n // Filter out empty containers. They do not affect indices.\n children = children.filter(p => {\n if (!p.isJSXExpressionContainer()) return true;\n const expr = p.get(\"expression\");\n return !expr.isJSXEmptyExpression();\n });\n\n // We can then iterate on the children.\n for (let [i, child] of children.entries()) {\n if (child.isJSXExpressionContainer()) {\n // We have an expression container: {…}\n const expression = child.get(\"expression\");\n const evaluation = evaluateIfConfident(expression);\n if (evaluation !== null && typeof evaluation === \"string\") {\n // We have an evaluable JSX expression like {'hello'}\n result += evaluation.toString();\n continue;\n }\n if (expression.isObjectExpression()) {\n // We have an expression like {{name}} or {{name: userName}}\n const it = iterateObjectExpression(expression);\n const key0 = it.next().value;\n if (!key0 || !it.next().done) {\n // Probably got empty object expression like {{}}\n // or {{foo,bar}}\n throw transComponentExtractionError;\n }\n result += `{{${key0[0]}}}`;\n continue;\n }\n if (expression.isIdentifier()) {\n // We have an identifier like {myPartialComponent}\n // We try to find the latest declaration and substitute the identifier.\n const declarationExpression = resolveIdentifier(expression);\n const evaluation = evaluateIfConfident(declarationExpression);\n if (evaluation !== null) {\n // It could be evaluated, it's probably something like 'hello'\n result += evaluation;\n continue;\n } else if (declarationExpression !== null && declarationExpression.isJSXElement()) {\n // It's a JSX element. Let's act as if it was inline and move along.\n child = declarationExpression;\n } else {\n throw transComponentExtractionError;\n }\n }\n }\n if (child.isJSXText()) {\n // Simple JSX text.\n result +=\n // Let's sanitize the value a bit.\n child.node.value\n // Strip line returns at start\n .replace(/^\\s*(\\r?\\n)+\\s*/gm, \"\")\n // Strip line returns at end\n .replace(/\\s*(\\r?\\n)+\\s*$/gm, \"\")\n // Replace other line returns with one space\n .replace(/\\s*(\\r?\\n)+\\s*/gm, \" \");\n continue;\n }\n if (child.isJSXElement()) {\n // got a JSX element.\n result += formatJSXElementKey(child, i, config);\n continue;\n }\n }\n return result;\n}\n\n/**\n * Parse `Trans` component to extract all its translation keys and i18next\n * options.\n *\n * @param path: node path of Trans JSX element.\n * @param config: plugin configuration\n * @param commentHints: parsed comment hints\n * @param skipCheck: set to true if you know that the JSXElement\n * already is a Trans component.\n */\nfunction extractTransComponent(path, config, commentHints = [], skipCheck = false) {\n if (getCommentHintForPath(path, \"DISABLE\", commentHints)) return [];\n if (!skipCheck && !isTransComponent(path)) return [];\n const keyEvaluationFromAttribute = parseTransComponentKeyFromAttributes(path);\n const keyEvaluationFromChildren = parseTransComponentKeyFromChildren(path, config);\n const parsedOptions = parseTransComponentOptions(path, commentHints);\n if (parsedOptions.defaultValue === null) {\n parsedOptions.defaultValue = keyEvaluationFromChildren;\n }\n return [{\n key: keyEvaluationFromAttribute || keyEvaluationFromChildren,\n parsedOptions,\n sourceNodes: [path.node],\n extractorName: extractTransComponent.name\n }];\n}\n\n/**\n * Extract custom Trans components.\n *\n * @param path: node path of potential custom Trans JSX element.\n * @param config: plugin configuration\n * @param commentHints: parsed comment hints\n */\nfunction extractCustomTransComponent(path, config, commentHints = []) {\n if (getCommentHintForPath(path, \"DISABLE\", commentHints)) return [];\n if (!isCustomImportedNode(config.cache.absoluteCustomTransComponents, path, path.get(\"openingElement\").get(\"name\"))) return [];\n return extractTransComponent(path, config, commentHints, true);\n}\n\n/**\n * Check whether a given CallExpression path is a global call to the `t`\n * function.\n *\n * @param path: node path to check\n * @param config: plugin configuration\n * @returns true if the given call expression is indeed a call to i18next.t.\n */\nfunction isSimpleTCall(path, config) {\n const callee = path.get(\"callee\");\n if (!callee.isIdentifier()) return false;\n return config.tFunctionNames.includes(callee.node.name);\n}\n\n/**\n * Parse options of a `t(…)` call.\n * @param path: NodePath representing the second argument of the `t()` call\n * (i.e. the i18next options)\n * @returns an object indicating whether the parsed options have context\n * and/or count.\n */\nfunction parseTCallOptions(path) {\n const res = {\n contexts: false,\n hasCount: false,\n ns: null,\n keyPrefix: null,\n defaultValue: null\n };\n if (!path) return res;\n\n // Try brutal evaluation of defaultValue first.\n const optsEvaluation = evaluateIfConfident(path);\n if (typeof optsEvaluation === \"string\") {\n res.defaultValue = optsEvaluation;\n } else if (path.isObjectExpression()) {\n // It didn't work. Let's try to parse as object expression.\n res.contexts = findKeyInObjectExpression(path, \"context\") !== null;\n res.hasCount = findKeyInObjectExpression(path, \"count\") !== null;\n const nsNode = findKeyInObjectExpression(path, \"ns\");\n if (nsNode !== null && nsNode.isObjectProperty()) {\n const nsValueNode = nsNode.get(\"value\");\n const nsEvaluation = evaluateIfConfident(nsValueNode);\n res.ns = getFirstOrNull(nsEvaluation);\n }\n const defaultValueNode = findKeyInObjectExpression(path, \"defaultValue\");\n if (defaultValueNode !== null && defaultValueNode.isObjectProperty()) {\n const defaultValueNodeValue = defaultValueNode.get(\"value\");\n res.defaultValue = evaluateIfConfident(defaultValueNodeValue);\n }\n const keyPrefixNode = findKeyInObjectExpression(path, \"keyPrefix\");\n if (keyPrefixNode !== null && keyPrefixNode.isObjectProperty()) {\n const keyPrefixNodeValue = keyPrefixNode.get(\"value\");\n res.keyPrefix = evaluateIfConfident(keyPrefixNodeValue);\n }\n }\n return res;\n}\n\n/**\n * Given a call to the `t()` function, find the key and the options.\n *\n * @param path NodePath of the `t()` call.\n * @param commentHints parsed comment hints\n * @throws ExtractionError when the extraction failed for the `t` call.\n */\nfunction extractTCall(path, commentHints) {\n const args = path.get(\"arguments\");\n const keyEvaluation = evaluateIfConfident(args[0]);\n const options = {\n ...parseTCallOptions(args[1]),\n ...parseI18NextOptionsFromCommentHints(path, commentHints)\n };\n const result = [];\n const keys = Array.isArray(keyEvaluation) ? keyEvaluation : [keyEvaluation];\n for (const key of keys) {\n if (typeof key !== \"string\") {\n throw new ExtractionError(`Couldn't evaluate i18next key. You should either make the key ` + `evaluable or skip the line using a skip comment (/* ` + `${COMMENT_HINTS_KEYWORDS.DISABLE.LINE} */ or /* ` + `${COMMENT_HINTS_KEYWORDS.DISABLE.NEXT_LINE} */).`, path);\n }\n result.push({\n key,\n parsedOptions: options,\n sourceNodes: [path.node],\n extractorName: extractTFunction.name\n });\n }\n return result;\n}\n\n/**\n * Parse a call expression (likely a call to a `t` function) to find its\n * translation keys and i18next options.\n *\n * @param path: node path of the t function call.\n * @param config: plugin configuration\n * @param commentHints: parsed comment hints\n * @param skipCheck: set to true if you know that the call expression arguments\n * already is a `t` function.\n */\nfunction extractTFunction(path, config, commentHints = [], skipCheck = false) {\n if (getCommentHintForPath(path, \"DISABLE\", commentHints)) return [];\n if (!skipCheck && !isSimpleTCall(path, config)) return [];\n return extractTCall(path, commentHints);\n}\n\n/**\n * Check whether a given CallExpression path is a call to `useTranslation` hook.\n * @param path: node path to check\n * @returns true if the given call expression is indeed a call to\n * `useTranslation`\n */\nfunction isUseTranslationHook(path) {\n const callee = path.get(\"callee\");\n return referencesImport(callee, \"react-i18next\", \"useTranslation\");\n}\n\n/**\n * Parse `useTranslation()` hook to extract all its translation keys and\n * options.\n * @param path: useTranslation call node path.\n * @param config: plugin configuration\n * @param commentHints: parsed comment hints\n */\nfunction extractUseTranslationHook(path, config, commentHints = [], skipCheck = false) {\n if (!skipCheck && !isUseTranslationHook(path)) return [];\n let ns;\n const nsCommentHint = getCommentHintForPath(path, \"NAMESPACE\", commentHints);\n if (nsCommentHint) {\n // We got a comment hint, take its value as namespace.\n ns = nsCommentHint.value;\n } else {\n // Otherwise, try to get namespace from arguments.\n const namespaceArgument = path.get(\"arguments\")[0];\n ns = getFirstOrNull(evaluateIfConfident(namespaceArgument));\n }\n const parentPath = path.parentPath;\n if (!parentPath.isVariableDeclarator()) return [];\n const id = parentPath.get(\"id\");\n const tBindingName = getAliasedTBindingName(id, config.tFunctionNames);\n if (!tBindingName) return [];\n const tBinding = id.scope.bindings[tBindingName];\n if (!tBinding) return [];\n let keyPrefix = null;\n const optionsArgument = path.get(\"arguments\")[1];\n const options = getFirstOrNull(evaluateIfConfident(optionsArgument));\n if (options) {\n keyPrefix = options.keyPrefix || keyPrefix;\n }\n let keys = Array();\n for (const reference of tBinding.referencePaths) {\n var _reference$parentPath;\n if ((_reference$parentPath = reference.parentPath) !== null && _reference$parentPath !== void 0 && _reference$parentPath.isCallExpression() && reference.parentPath.get(\"callee\") === reference) {\n keys = [...keys, ...extractTFunction(reference.parentPath, config, commentHints, true).map(k => ({\n // Add namespace if it was not explicitely set in t() call.\n ...k,\n parsedOptions: {\n ...k.parsedOptions,\n keyPrefix: k.parsedOptions.keyPrefix || keyPrefix,\n ns: k.parsedOptions.ns || ns\n }\n }))];\n }\n }\n return keys.map(k => ({\n ...k,\n sourceNodes: [path.node, ...k.sourceNodes],\n extractorName: extractUseTranslationHook.name\n }));\n}\n\n/**\n * Extract custom useTranslation hooks.\n *\n * @param path: node path of potential custom useTranslation hook calls.\n * @param config: plugin configuration\n * @param commentHints: parsed comment hints\n */\nfunction extractCustomUseTranslationHook(path, config, commentHints = []) {\n if (getCommentHintForPath(path, \"DISABLE\", commentHints)) return [];\n if (!isCustomImportedNode(config.cache.absoluteCustomHooks, path, path.get(\"callee\"))) {\n return [];\n }\n return extractUseTranslationHook(path, config, commentHints, true);\n}\n\n/**\n * Check whether a given CallExpression path is a call to `getFixedT()`\n * function.\n * @param path: node path to check\n * @param config: plugin configuration\n * @returns true if the given call expression is indeed a call to\n * `getFixedT`\n */\nfunction isGetFixedTFunction(path, config) {\n const callee = path.get(\"callee\");\n return referencesChildIdentifier(callee, config.i18nextInstanceNames, \"getFixedT\");\n}\n\n/**\n * Parse `getFixedT()` getter to extract all its translation keys and\n * options (see https://www.i18next.com/overview/api#getfixedt)\n * @param path: useTranslation call node path.\n * @param config: plugin configuration\n * @param commentHints: parsed comment hints\n */\nfunction extractGetFixedTFunction(path, config, commentHints = []) {\n if (!isGetFixedTFunction(path, config)) return [];\n let ns;\n const nsCommentHint = getCommentHintForPath(path, \"NAMESPACE\", commentHints);\n if (nsCommentHint) {\n // We got a comment hint, take its value as namespace.\n ns = nsCommentHint.value;\n } else {\n // Otherwise, try to get namespace from arguments.\n const namespaceArgument = path.get(\"arguments\")[1];\n ns = getFirstOrNull(evaluateIfConfident(namespaceArgument));\n }\n const parentPath = path.parentPath;\n if (!parentPath.isVariableDeclarator()) return [];\n const id = parentPath.get(\"id\");\n if (!id.isIdentifier()) return [];\n const tBinding = id.scope.bindings[id.node.name];\n if (!tBinding) return [];\n const keyPrefixArgument = path.get(\"arguments\")[2];\n const keyPrefix = getFirstOrNull(evaluateIfConfident(keyPrefixArgument));\n let keys = Array();\n for (const reference of tBinding.referencePaths) {\n var _reference$parentPath;\n if ((_reference$parentPath = reference.parentPath) !== null && _reference$parentPath !== void 0 && _reference$parentPath.isCallExpression() && reference.parentPath.get(\"callee\") === reference) {\n keys = [...keys, ...extractTFunction(reference.parentPath, config, commentHints, true).map(k => ({\n // Add namespace if it was not explicitely set in t() call.\n ...k,\n parsedOptions: {\n ...k.parsedOptions,\n keyPrefix: k.parsedOptions.keyPrefix || keyPrefix,\n ns: k.parsedOptions.ns || ns\n }\n }))];\n }\n }\n return keys.map(k => ({\n ...k,\n sourceNodes: [path.node, ...k.sourceNodes],\n extractorName: extractGetFixedTFunction.name\n }));\n}\n\n/**\n * Check whether a given CallExpression path is a global call to `i18next.t`\n * function.\n * @param path: node path to check\n * @param config: plugin configuration\n * @returns true if the given call expression is indeed a call to i18next.t.\n */\nfunction isI18nextTCall(path, config) {\n const callee = path.get(\"callee\");\n return referencesChildIdentifier(callee, config.i18nextInstanceNames, \"t\");\n}\n\n/**\n * Parse a call expression (likely `i18next.t`) to find its translation keys\n * and i18next options.\n *\n * @param path: node path of the t function call.\n * @param config: plugin configuration\n * @param commentHints: parsed comment hints\n * @param skipCheck: set to true if you know that the call expression arguments\n * already is a `t` function.\n */\nfunction extractI18nextInstance(path, config, commentHints = []) {\n if (getCommentHintForPath(path, \"DISABLE\", commentHints)) return [];\n if (!isI18nextTCall(path, config)) return [];\n return extractTFunction(path, config, commentHints, true).map(k => ({\n ...k,\n sourceNodes: [path.node, ...k.sourceNodes],\n extractorName: extractI18nextInstance.name\n }));\n}\n\n/**\n * Check whether a given JSXElement is a Translation render prop.\n * @param path: node path to check\n * @returns true if the given element is indeed a `Translation` render prop.\n */\nfunction isTranslationRenderProp(path) {\n const openingElement = path.get(\"openingElement\");\n return referencesImport(openingElement.get(\"name\"), \"react-i18next\", \"Translation\");\n}\n\n/**\n * Parse `Translation` render prop to extract all its translation keys and\n * options.\n *\n * @param path: node path of Translation JSX element.\n * @param config: plugin configuration\n * @param commentHints: parsed comment hints\n */\nfunction extractTranslationRenderProp(path, config, commentHints = []) {\n if (!isTranslationRenderProp(path)) return [];\n let ns;\n const nsCommentHint = getCommentHintForPath(path, \"NAMESPACE\", commentHints);\n if (nsCommentHint) {\n // We got a comment hint, take its value as namespace.\n ns = nsCommentHint.value;\n } else {\n // Try to parse ns property\n const nsAttr = findJSXAttributeByName(path, \"ns\");\n if (nsAttr) {\n let value = nsAttr.get(\"value\");\n if (value.isJSXExpressionContainer()) value = value.get(\"expression\");\n ns = getFirstOrNull(evaluateIfConfident(value));\n }\n }\n\n // We expect at least \"