@lingo.dev/compiler 0.1.0

package/build/plugin/transform/process-file.mjs

@@ -0,0 +1,390 @@
+import { logger } from "../../utils/logger.mjs";
+import { comstructUnifiedImport, constructServerImport, constructTranslationCall, createTranslationEntry, escapeTextForICU, hasUseI18nDirective, inferComponentName, injectServerHook, injectUnifiedHook, isReactComponent, isVoidElement, normalizeWhitespace } from "./utils.mjs";
+import { processNextDynamicMetadata, processNextStaticMetadata } from "./metadata.mjs";
+import { traverse } from "./babel-compat.mjs";
+import { processOverrideAttributes } from "./parse-override.mjs";
+import * as t from "@babel/types";
+
+//#region src/plugin/transform/process-file.ts
+/**
+* Keep mutations to the current node and children. Do not mutate program inserting imports when processing the component.
+* This should be done in the end.
+* The overall idea is that state is used for side effect tracking. When we exit relevant points, we check if we need to make extra changes at this level.
+* e.g. when we transform elements to insert translations, we record their hashes and add the translation hook call when leaving the component.
+*/
+function updateWithMetadataState(state, newState) {
+	state.newEntries = [...state.newEntries, ...newState.newEntries];
+	state.needsAsyncImport = state.needsAsyncImport || newState.needsAsyncImport;
+	return state;
+}
+const SKIP_ATTRIBUTE = "data-lingo-skip";
+/**
+* Elements whose content should not be translated by default.
+* These are typically code-related or technical elements where translation
+* would break functionality or meaning.
+*/
+const NON_TRANSLATABLE_ELEMENTS = new Set([
+	"code",
+	"pre",
+	"script",
+	"style",
+	"kbd",
+	"samp",
+	"var"
+]);
+const TRANSLATABLE_ATTRIBUTES = new Set([
+	"title",
+	"aria-label",
+	"aria-description",
+	"alt",
+	"label",
+	"description",
+	"placeholder",
+	"content",
+	"subtitle"
+]);
+/**
+* Check if a JSX element should skip translation based on:
+* 1. Element type (code, pre, script, style, etc.)
+* 2. translate="no" attribute (HTML standard)
+* 3. data-lingo-skip attribute
+*/
+function shouldSkipTranslationForElement(element) {
+	if (element.type === "JSXFragment") return false;
+	const openingElement = element.openingElement;
+	if (openingElement.name.type === "JSXIdentifier") {
+		if (NON_TRANSLATABLE_ELEMENTS.has(openingElement.name.name)) return true;
+	}
+	for (const attr of openingElement.attributes) if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier") {
+		if (attr.name.name === "translate") {
+			if (attr.value?.type === "StringLiteral" && attr.value.value === "no") return true;
+		}
+		if (attr.name.name === SKIP_ATTRIBUTE) return true;
+	}
+	return false;
+}
+function translateAttributes(node, state) {
+	const openingElement = node.openingElement;
+	const component = state.componentsStack.at(-1);
+	if (!component) return;
+	for (const attr of openingElement.attributes) if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && TRANSLATABLE_ATTRIBUTES.has(attr.name.name) && attr.value?.type === "StringLiteral") {
+		const text = normalizeWhitespace(attr.value.value);
+		if (text.length == 0) continue;
+		const entry = createTranslationEntry("attribute", text, {
+			attributeName: attr.name.name,
+			componentName: component.name
+		}, state.filePath, node.loc?.start.line, node.loc?.start.column);
+		registerEntry(entry, state, component.name);
+		attr.value = constructTranslationCall(entry.hash, text);
+	}
+}
+/**
+* Check if a JSX element has mixed content that needs rich text translation
+* Mixed content = text nodes + expressions + nested JSX elements (excluding void elements)
+*/
+function hasMixedContent(element) {
+	const children = element.children;
+	if (children.length === 0) return false;
+	let state = 0;
+	for (const child of children) if (child.type === "JSXText") {
+		if (child.value.trim().length > 0) switch (state) {
+			case 0:
+				state = 1;
+				break;
+			case 1: break;
+			case 2: return true;
+			case 3: return true;
+		}
+	} else if (child.type === "JSXExpressionContainer") switch (state) {
+		case 0:
+			state = 2;
+			break;
+		case 1: return true;
+		case 2: break;
+		case 3: return true;
+	}
+	else if (child.type === "JSXElement") if (!isVoidElement(child)) switch (state) {
+		case 0:
+			state = 2;
+			break;
+		case 1: return true;
+		case 2: break;
+		case 3: return true;
+	}
+	else switch (state) {
+		case 0: break;
+		case 1:
+			state = 3;
+			break;
+		case 2: break;
+		case 3: break;
+	}
+	return false;
+}
+/**
+* Serialize JSX children to a translation string with placeholders
+*/
+function serializeJSXChildren(children, state) {
+	let text = "";
+	const variables = [];
+	const expressions = /* @__PURE__ */ new Map();
+	const components = /* @__PURE__ */ new Map();
+	const elementCounts = /* @__PURE__ */ new Map();
+	for (const child of children) if (child.type === "JSXText") {
+		let normalized = normalizeWhitespace(child.value);
+		if (text.length > 0 && child.value.match(/^\s/) && normalized.length > 0) {
+			if (!text.endsWith(" ")) normalized = ` ${normalized}`;
+		}
+		if (normalized.length > 0 && child.value.match(/\s$/)) {
+			if (!text.endsWith(" ")) normalized = `${normalized} `;
+		}
+		text += escapeTextForICU(normalized);
+	} else if (child.type === "JSXExpressionContainer") {
+		const expr = child.expression;
+		if (expr.type === "Identifier") {
+			text += `{${expr.name}}`;
+			if (!variables.includes(expr.name)) variables.push(expr.name);
+		} else if (expr.type === "StringLiteral") text += escapeTextForICU(expr.value);
+		else if (expr.type !== "JSXEmptyExpression") {
+			const name = `expression${expressions.size}`;
+			text += `{${name}}`;
+			expressions.set(name, expr);
+		}
+	} else if (child.type === "JSXElement") {
+		let shouldTranslate = true;
+		if (isVoidElement(child)) shouldTranslate = false;
+		if (shouldSkipTranslationForElement(child)) shouldTranslate = false;
+		const openingElement = child.openingElement;
+		let elementName = "";
+		if (openingElement.name.type === "JSXIdentifier") elementName = openingElement.name.name;
+		else elementName = "element";
+		const count = elementCounts.get(elementName) || 0;
+		elementCounts.set(elementName, count + 1);
+		const tagName = `${elementName}${count}`;
+		translateAttributes(child, state);
+		if (shouldTranslate) {
+			const nested = serializeJSXChildren(child.children, state);
+			text += `<${tagName}>${nested.text}</${tagName}>`;
+			for (const v of nested.variables) if (!variables.includes(v)) variables.push(v);
+			for (const [nestedTag, nestedElement] of nested.components) components.set(`${tagName}_${nestedTag}`, nestedElement);
+		} else {
+			text += `<${tagName}></${tagName}>`;
+			child.extra = {
+				...child.extra,
+				shouldTranslate: false
+			};
+		}
+		components.set(tagName, child);
+	}
+	return {
+		text,
+		variables,
+		expressions,
+		components
+	};
+}
+function transformVoidElement(node, state) {
+	translateAttributes(node, state);
+}
+function getTranslationScope(node, state) {
+	if (hasMixedContent(node)) {
+		const serialized = serializeJSXChildren(node.children, state);
+		const text$1 = serialized.text.trim();
+		if (text$1.length === 0) return null;
+		return {
+			kind: "mixed",
+			text: text$1,
+			args: {
+				variables: serialized.variables,
+				expressions: serialized.expressions,
+				components: serialized.components
+			}
+		};
+	}
+	const textNodeIndex = node.children.findIndex((child) => child.type === "JSXText" && child.value.trim().length > 0);
+	if (textNodeIndex === -1) return null;
+	if (!node.children.every((child) => child.type === "JSXText" || child.type === "JSXElement" && isVoidElement(child))) return null;
+	const textNode = node.children[textNodeIndex];
+	const text = normalizeWhitespace(textNode.value);
+	if (text.length === 0) return null;
+	return {
+		kind: "text",
+		text,
+		textNodeIndex
+	};
+}
+function registerEntry(entry, state, componentName) {
+	state.newEntries.push(entry);
+	const hashes = state.componentHashes.get(componentName) ?? [];
+	hashes.push(entry.hash);
+	state.componentHashes.set(componentName, hashes);
+}
+function rewriteChildren(path, state, translationScope, entryHash) {
+	if (translationScope.kind === "mixed") {
+		path.node.children = [constructTranslationCall(entryHash, translationScope.text, translationScope.args)];
+		return;
+	}
+	const { textNodeIndex, text } = translationScope;
+	path.node.children = path.node.children.map((child, index) => {
+		if (index === textNodeIndex) return constructTranslationCall(entryHash, text);
+		if (child.type === "JSXElement") transformVoidElement(child, state);
+		return child;
+	});
+}
+function processJSXElement(path, state) {
+	const component = state.componentsStack.at(-1);
+	if (!component) return;
+	const scope = getTranslationScope(path.node, state);
+	if (!scope) return;
+	const overrides = processOverrideAttributes(path);
+	const entry = createTranslationEntry("content", scope.text, { componentName: component.name }, state.filePath, path.node.loc?.start.line, path.node.loc?.start.column, overrides);
+	registerEntry(entry, state, component.name);
+	rewriteChildren(path, state, scope, entry.hash);
+	path.skip();
+}
+/**
+* Inject dynamic locale attribute into <html> elements
+* Transforms: <html> → <html lang={locale}>
+*
+* Only injects if:
+* 1. Element is <html>
+* 2. No existing lang/language attribute
+* 3. We're inside a React component (has locale context)
+*/
+function injectHtmlLangAttribute(node, state) {
+	const openingElement = node.openingElement;
+	if (openingElement.name.type !== "JSXIdentifier" || openingElement.name.name !== "html") return;
+	if (openingElement.attributes.some((attr) => {
+		return attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && (attr.name.name === "lang" || attr.name.name === "language");
+	})) return;
+	const component = state.componentsStack.at(-1);
+	if (!component) return;
+	const langAttr = t.jsxAttribute(t.jsxIdentifier("lang"), t.jsxExpressionContainer(t.identifier("locale")));
+	openingElement.attributes.push(langAttr);
+	logger.debug(`Injected locale attribute into <html> element in component: ${component.name}`);
+	state.componentsNeedingLocale.add(component.name);
+}
+/**
+* Inject translation hook into a component when it's done processing
+* Called when popping component from stack
+*/
+function injectTranslationHook(path, component, state) {
+	const needsLocale = state.componentsNeedingLocale.has(component.name);
+	const hashes = state.componentHashes.get(component.name);
+	if ((!hashes || hashes.length === 0) && !needsLocale) return;
+	if (component.isAsync) {
+		injectServerHook(path, hashes ?? [], needsLocale);
+		state.needsAsyncImport = true;
+	} else {
+		injectUnifiedHook(path, hashes ?? [], needsLocale);
+		state.needsUnifiedImport = true;
+	}
+}
+/**
+* Add translation imports at the top of the file
+* Called on Program exit after all components have been processed
+*/
+function addTranslationImports(programPath, state) {
+	if (state.needsAsyncImport) programPath.node.body.unshift(constructServerImport());
+	if (state.needsUnifiedImport) programPath.node.body.unshift(comstructUnifiedImport());
+}
+/**
+* Handle component function detection and state update
+*/
+function processComponentFunction(path, state) {
+	if (!isReactComponent(path)) {
+		path.skip();
+		logger.debug(`Skipping non-React component: ${path.node.type}`);
+		return;
+	}
+	const componentName = inferComponentName(path);
+	if (!componentName) {
+		path.skip();
+		return;
+	}
+	if (!state.componentHashes.has(componentName)) state.componentHashes.set(componentName, []);
+	const componentEntry = {
+		name: componentName,
+		isAsync: path.node.async
+	};
+	state.componentsStack.push(componentEntry);
+	logger.debug(`Component ${JSON.stringify(componentEntry)} entered`);
+	path.setData("componentName", componentName);
+	path.traverse(componentVisitors, { visitorState: state });
+	const component = state.componentsStack.pop();
+	if (component) injectTranslationHook(path, component, state);
+	path.skip();
+}
+const componentVisitors = {
+	FunctionDeclaration(path) {
+		processComponentFunction(path, this.visitorState);
+	},
+	ArrowFunctionExpression(path) {
+		processComponentFunction(path, this.visitorState);
+	},
+	FunctionExpression(path) {
+		processComponentFunction(path, this.visitorState);
+	},
+	JSXFragment(path) {
+		processJSXElement(path, this.visitorState);
+	},
+	JSXElement(path) {
+		translateAttributes(path.node, this.visitorState);
+		injectHtmlLangAttribute(path.node, this.visitorState);
+		if (shouldSkipTranslationForElement(path.node)) {
+			path.skip();
+			return;
+		}
+		processJSXElement(path, this.visitorState);
+	}
+};
+const fileVisitors = {
+	ExportNamedDeclaration(path) {
+		const metadataState = processNextStaticMetadata(path, { filePath: this.visitorState.filePath });
+		if (metadataState) updateWithMetadataState(this.visitorState, metadataState);
+	},
+	FunctionDeclaration(path) {
+		const metadataState = processNextDynamicMetadata(path, { filePath: this.visitorState.filePath });
+		if (metadataState) updateWithMetadataState(this.visitorState, metadataState);
+		processComponentFunction(path, this.visitorState);
+	},
+	ArrowFunctionExpression(path) {
+		processComponentFunction(path, this.visitorState);
+	},
+	FunctionExpression(path) {
+		processComponentFunction(path, this.visitorState);
+	}
+};
+/**
+* Create Babel visitors for auto-translation (single-pass transformation)
+*/
+const programVisitor = { Program: {
+	enter(path) {
+		if (this.visitorState.needsDirective && !hasUseI18nDirective(path)) {
+			path.skip();
+			return;
+		}
+		path.traverse(fileVisitors, { visitorState: this.visitorState });
+	},
+	exit(path) {
+		if (this.visitorState.needsUnifiedImport || this.visitorState.needsAsyncImport) addTranslationImports(path, this.visitorState);
+	}
+} };
+function processFile(ast, options) {
+	const state = {
+		needsDirective: options.needsDirective,
+		filePath: options.relativeFilePath,
+		newEntries: [],
+		componentsStack: [],
+		componentHashes: /* @__PURE__ */ new Map(),
+		needsUnifiedImport: false,
+		needsAsyncImport: false,
+		componentsNeedingLocale: /* @__PURE__ */ new Set()
+	};
+	traverse(ast, programVisitor, void 0, { visitorState: state });
+	return state.newEntries;
+}
+
+//#endregion
+export { processFile };
+//# sourceMappingURL=process-file.mjs.map

package/build/plugin/transform/process-file.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-file.mjs","names":["variables: string[]","text","componentEntry: ComponentEntry","state: VisitorsInternalState"],"sources":["../../../src/plugin/transform/process-file.ts"],"sourcesContent":["/**\n * Keep mutations to the current node and children. Do not mutate program inserting imports when processing the component.\n * This should be done in the end.\n * The overall idea is that state is used for side effect tracking. When we exit relevant points, we check if we need to make extra changes at this level.\n * e.g. when we transform elements to insert translations, we record their hashes and add the translation hook call when leaving the component.\n */\nimport * as t from \"@babel/types\";\nimport type { NodePath, TraverseOptions } from \"@babel/traverse\";\nimport type { TranslationEntry } from \"../../types\";\nimport { logger } from \"../../utils/logger\";\nimport {\n  comstructUnifiedImport,\n  constructServerImport,\n  constructTranslationCall,\n  createTranslationEntry,\n  escapeTextForICU,\n  hasUseI18nDirective,\n  inferComponentName,\n  injectServerHook,\n  injectUnifiedHook,\n  isReactComponent,\n  isVoidElement,\n  normalizeWhitespace,\n} from \"./utils\";\nimport {\n  type MetadataOutputState,\n  processNextDynamicMetadata,\n  processNextStaticMetadata,\n} from \"./metadata\";\nimport { traverse } from \"./babel-compat\";\nimport { processOverrideAttributes } from \"./parse-override\";\n\ntype ComponentEntry = {\n  name: string;\n  isAsync: boolean;\n};\n\n/**\n * State shared between all the visitors.\n */\nexport interface VisitorsInternalState {\n  needsDirective: boolean;\n  filePath: string;\n  newEntries: TranslationEntry[];\n  /** Stores component encountered up the tree at the current point, to avoid lookups. */\n  componentsStack: ComponentEntry[];\n  /** Map component names to their translation hashes */\n  componentHashes: Map<string, string[]>;\n  /** Track metadata functions that need translation */\n  /** Track if we need the unified hook import */\n  needsUnifiedImport: boolean;\n  /** Track if we need the async API import */\n  needsAsyncImport: boolean;\n  /** Track which components need locale from hook (for <html> lang attribute) */\n  componentsNeedingLocale: Set<string>;\n}\n\nfunction updateWithMetadataState(\n  state: VisitorsInternalState,\n  newState: MetadataOutputState,\n): VisitorsInternalState {\n  state.newEntries = [...state.newEntries, ...newState.newEntries];\n  state.needsAsyncImport = state.needsAsyncImport || newState.needsAsyncImport;\n  return state;\n}\n\nconst SKIP_ATTRIBUTE = \"data-lingo-skip\";\n\n/**\n * Elements whose content should not be translated by default.\n * These are typically code-related or technical elements where translation\n * would break functionality or meaning.\n */\nconst NON_TRANSLATABLE_ELEMENTS = new Set([\n  \"code\",\n  \"pre\",\n  \"script\",\n  \"style\",\n  \"kbd\",\n  \"samp\",\n  \"var\",\n]);\n\nconst TRANSLATABLE_ATTRIBUTES = new Set([\n  \"title\",\n  \"aria-label\",\n  \"aria-description\",\n  \"alt\",\n  \"label\",\n  \"description\",\n  \"placeholder\",\n  \"content\",\n  \"subtitle\",\n]);\n\n/**\n * Check if a JSX element should skip translation based on:\n * 1. Element type (code, pre, script, style, etc.)\n * 2. translate=\"no\" attribute (HTML standard)\n * 3. data-lingo-skip attribute\n */\nfunction shouldSkipTranslationForElement(\n  element: t.JSXElement | t.JSXFragment,\n): boolean {\n  // We always translate fragments\n  if (element.type === \"JSXFragment\") {\n    return false;\n  }\n  const openingElement = element.openingElement;\n\n  // Check element type\n  if (openingElement.name.type === \"JSXIdentifier\") {\n    if (NON_TRANSLATABLE_ELEMENTS.has(openingElement.name.name)) {\n      return true;\n    }\n  }\n\n  for (const attr of openingElement.attributes) {\n    if (attr.type === \"JSXAttribute\" && attr.name.type === \"JSXIdentifier\") {\n      // Check for translate=\"no\" (HTML standard)\n      if (attr.name.name === \"translate\") {\n        if (attr.value?.type === \"StringLiteral\" && attr.value.value === \"no\") {\n          return true;\n        }\n      }\n\n      if (attr.name.name === SKIP_ATTRIBUTE) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n}\n\n// Called even on the element which are not translatable.\nfunction translateAttributes(\n  node: t.JSXElement,\n  state: VisitorsInternalState,\n): void {\n  const openingElement = node.openingElement;\n\n  const component = state.componentsStack.at(-1);\n  if (!component) return;\n\n  for (const attr of openingElement.attributes) {\n    if (\n      attr.type === \"JSXAttribute\" &&\n      attr.name.type === \"JSXIdentifier\" &&\n      TRANSLATABLE_ATTRIBUTES.has(attr.name.name) &&\n      attr.value?.type === \"StringLiteral\"\n    ) {\n      const text = normalizeWhitespace(attr.value.value);\n      if (text.length == 0) continue;\n\n      const entry = createTranslationEntry(\n        \"attribute\",\n        text,\n        {\n          attributeName: attr.name.name,\n          componentName: component.name,\n        },\n        state.filePath,\n        node.loc?.start.line,\n        node.loc?.start.column,\n      );\n      registerEntry(entry, state, component.name);\n\n      attr.value = constructTranslationCall(entry.hash, text);\n    }\n  }\n}\n\n/**\n * Check if a JSX element has mixed content that needs rich text translation\n * Mixed content = text nodes + expressions + nested JSX elements (excluding void elements)\n */\nfunction hasMixedContent(element: t.JSXElement | t.JSXFragment): boolean {\n  const children = element.children;\n  if (children.length === 0) return false;\n  // 001\n  // 221\n  // 101\n  // States:\n  // 0 - no text or translatable nodes\n  // 1 - text node\n  // 2 - expression or translatable element\n  // 3 - interrupted text node\n  // 4 - mixed\n  //\n  let state = 0;\n\n  for (const child of children) {\n    if (child.type === \"JSXText\") {\n      if (child.value.trim().length > 0) {\n        switch (state) {\n          case 0:\n            state = 1;\n            break;\n          case 1:\n            break;\n          case 2:\n            return true;\n          case 3:\n            return true;\n        }\n      }\n      // Expressions require a substitution of the placeholder and are usually a part of the text so should be translated in one context\n    } else if (child.type === \"JSXExpressionContainer\") {\n      switch (state) {\n        case 0:\n          state = 2;\n          break;\n        case 1:\n          return true;\n        case 2:\n          break;\n        case 3:\n          return true;\n      }\n    } else if (child.type === \"JSXElement\") {\n      if (!isVoidElement(child)) {\n        switch (state) {\n          case 0:\n            state = 2;\n            break;\n          case 1:\n            return true;\n          case 2:\n            break;\n          case 3:\n            return true;\n        }\n      } else {\n        switch (state) {\n          case 0:\n            break;\n          case 1:\n            state = 3;\n            break;\n          case 2:\n            break;\n          case 3:\n            break;\n        }\n      }\n    }\n  }\n  return false;\n}\n\n/**\n * Result of serializing JSX children to a translation string\n */\ninterface SerializedJSX {\n  /** The serialized string with placeholders, e.g. \"Hello {name}, you have <strong0>{count}</strong0> messages\" */\n  text: string;\n  /** Variable identifiers extracted from expressions, e.g. [\"name\", \"count\"] */\n  variables: string[];\n  expressions: Map<string, t.Expression>;\n  /** Component mappings for nested elements, e.g. { strong0: <strong>...</strong> } */\n  components: Map<string, t.JSXElement>;\n}\n\n/**\n * Serialize JSX children to a translation string with placeholders\n */\nfunction serializeJSXChildren(\n  children: Array<\n    | t.JSXText\n    | t.JSXExpressionContainer\n    | t.JSXElement\n    | t.JSXSpreadChild\n    | t.JSXFragment\n  >,\n  state: VisitorsInternalState,\n): SerializedJSX {\n  let text = \"\";\n  const variables: string[] = [];\n  const expressions = new Map<string, t.Expression>();\n  const components = new Map<string, t.JSXElement>();\n  const elementCounts = new Map<string, number>();\n\n  for (const child of children) {\n    if (child.type === \"JSXText\") {\n      // Normalize whitespace within this text node\n      let normalized = normalizeWhitespace(child.value);\n\n      // If we have accumulated text and this node starts with whitespace,\n      // ensure there's a space separator\n      if (\n        text.length > 0 &&\n        child.value.match(/^\\s/) &&\n        normalized.length > 0\n      ) {\n        if (!text.endsWith(\" \")) {\n          normalized = ` ${normalized}`;\n        }\n      }\n\n      // If this node ends with whitespace and has content, add trailing space\n      if (normalized.length > 0 && child.value.match(/\\s$/)) {\n        if (!text.endsWith(\" \")) {\n          normalized = `${normalized} `;\n        }\n      }\n\n      text += escapeTextForICU(normalized);\n    } else if (child.type === \"JSXExpressionContainer\") {\n      // Extract variable name from expression\n      const expr = child.expression;\n      if (expr.type === \"Identifier\") {\n        text += `{${expr.name}}`;\n        if (!variables.includes(expr.name)) {\n          variables.push(expr.name);\n        }\n      } else if (expr.type === \"StringLiteral\") {\n        // String literal (like {\" \"}) - include the literal text directly\n        text += escapeTextForICU(expr.value);\n      } else if (expr.type !== \"JSXEmptyExpression\") {\n        const name = `expression${expressions.size}`;\n        text += `{${name}}`;\n        expressions.set(name, expr);\n      }\n    } else if (child.type === \"JSXElement\") {\n      let shouldTranslate = true;\n      // Skip void elements (they cannot have children and shouldn't be in rich text)\n      if (isVoidElement(child)) {\n        // Void elements are ignored in the translation string\n        // They will remain in their original position in the JSX tree\n        shouldTranslate = false;\n      }\n\n      // Skip elements that should not be translated (code, pre, etc.)\n      // These elements remain in the JSX tree but are not included in translation\n      if (shouldSkipTranslationForElement(child)) {\n        shouldTranslate = false;\n      }\n\n      // Get element name\n      const openingElement = child.openingElement;\n      let elementName = \"\";\n      if (openingElement.name.type === \"JSXIdentifier\") {\n        elementName = openingElement.name.name;\n      } else {\n        // TODO (AleksandrSl 02/12/2025): What is this corner case?\n        //  I thought it may be a fragment, but it seems that fragment is a separate JSXFragment node.\n        elementName = \"element\";\n      }\n\n      // Generate unique tag name with index\n      const count = elementCounts.get(elementName) || 0;\n      elementCounts.set(elementName, count + 1);\n      const tagName = `${elementName}${count}`;\n\n      translateAttributes(child, state);\n\n      if (shouldTranslate) {\n        // Recursively serialize nested content\n        const nested = serializeJSXChildren(child.children, state);\n        text += `<${tagName}>${nested.text}</${tagName}>`;\n\n        // Merge nested variables\n        for (const v of nested.variables) {\n          if (!variables.includes(v)) {\n            variables.push(v);\n          }\n        }\n\n        // Merge nested component mappings with prefixes to avoid conflicts\n        for (const [nestedTag, nestedElement] of nested.components) {\n          components.set(`${tagName}_${nestedTag}`, nestedElement);\n        }\n      } else {\n        // There is no support for self-closing tags in format js, so we should generate empty ones.\n        text += `<${tagName}></${tagName}>`;\n        child.extra = {\n          ...child.extra,\n          shouldTranslate: false,\n        };\n      }\n\n      // Store component mapping\n      components.set(tagName, child);\n    }\n  }\n\n  return { text, variables, expressions, components };\n}\n\nfunction transformVoidElement(\n  node: t.JSXElement,\n  state: VisitorsInternalState,\n) {\n  translateAttributes(node, state);\n}\n\ntype TranslationScope =\n  | { kind: \"mixed\"; text: string; args: any }\n  | { kind: \"text\"; text: string; textNodeIndex: number };\n\nfunction getTranslationScope(\n  node: t.JSXElement | t.JSXFragment,\n  state: VisitorsInternalState,\n): TranslationScope | null {\n  if (hasMixedContent(node)) {\n    const serialized = serializeJSXChildren(node.children, state);\n    const text = serialized.text.trim();\n    if (text.length === 0) return null;\n\n    return {\n      kind: \"mixed\",\n      text,\n      args: {\n        variables: serialized.variables,\n        expressions: serialized.expressions,\n        components: serialized.components,\n      },\n    };\n  }\n\n  // Non-mixed: allow exactly one meaningful JSXText + optional void elements + whitespace\n  const textNodeIndex = node.children.findIndex(\n    (child) => child.type === \"JSXText\" && child.value.trim().length > 0,\n  );\n  if (textNodeIndex === -1) return null;\n\n  const allowed = node.children.every(\n    (child) =>\n      child.type === \"JSXText\" ||\n      (child.type === \"JSXElement\" && isVoidElement(child)),\n  );\n  if (!allowed) return null;\n\n  const textNode = node.children[textNodeIndex] as t.JSXText;\n  const text = normalizeWhitespace(textNode.value);\n  if (text.length === 0) return null;\n\n  return { kind: \"text\", text, textNodeIndex };\n}\n\nfunction registerEntry(\n  entry: ReturnType<typeof createTranslationEntry>,\n  state: VisitorsInternalState,\n  componentName: string,\n) {\n  state.newEntries.push(entry);\n\n  const hashes = state.componentHashes.get(componentName) ?? [];\n  hashes.push(entry.hash);\n  state.componentHashes.set(componentName, hashes);\n}\n\nfunction rewriteChildren(\n  path: NodePath<t.JSXElement | t.JSXFragment>,\n  state: VisitorsInternalState,\n  translationScope: TranslationScope,\n  entryHash: string,\n) {\n  if (translationScope.kind === \"mixed\") {\n    path.node.children = [\n      constructTranslationCall(\n        entryHash,\n        translationScope.text,\n        translationScope.args,\n      ),\n    ];\n    return;\n  }\n\n  const { textNodeIndex, text } = translationScope;\n\n  path.node.children = path.node.children.map((child, index) => {\n    if (index === textNodeIndex) {\n      return constructTranslationCall(entryHash, text);\n    }\n    if (child.type === \"JSXElement\") {\n      transformVoidElement(child, state);\n    }\n    return child;\n  });\n}\n\nfunction processJSXElement(\n  path: NodePath<t.JSXElement | t.JSXFragment>,\n  state: VisitorsInternalState,\n): void {\n  const component = state.componentsStack.at(-1);\n  if (!component) return;\n\n  const scope = getTranslationScope(path.node, state);\n  if (!scope) return;\n\n  const overrides = processOverrideAttributes(path);\n\n  const entry = createTranslationEntry(\n    \"content\",\n    scope.text,\n    { componentName: component.name },\n    state.filePath,\n    path.node.loc?.start.line,\n    path.node.loc?.start.column,\n    overrides,\n  );\n\n  registerEntry(entry, state, component.name);\n  rewriteChildren(path, state, scope, entry.hash);\n\n  path.skip();\n}\n\n/**\n * Inject dynamic locale attribute into <html> elements\n * Transforms: <html> → <html lang={locale}>\n *\n * Only injects if:\n * 1. Element is <html>\n * 2. No existing lang/language attribute\n * 3. We're inside a React component (has locale context)\n */\nfunction injectHtmlLangAttribute(\n  node: t.JSXElement,\n  state: VisitorsInternalState,\n): void {\n  const openingElement = node.openingElement;\n\n  if (\n    openingElement.name.type !== \"JSXIdentifier\" ||\n    openingElement.name.name !== \"html\"\n  ) {\n    return;\n  }\n\n  // Check if lang attribute already exists\n  const hasLangAttr = openingElement.attributes.some((attr) => {\n    return (\n      attr.type === \"JSXAttribute\" &&\n      attr.name.type === \"JSXIdentifier\" &&\n      (attr.name.name === \"lang\" || attr.name.name === \"language\")\n    );\n  });\n\n  if (hasLangAttr) {\n    // Already has lang attribute, don't inject\n    return;\n  }\n\n  // Check if we're inside a component (has access to locale context)\n  const component = state.componentsStack.at(-1);\n  if (!component) {\n    // Not inside a component, can't inject locale\n    return;\n  }\n\n  // Inject lang={locale} attribute\n  // This creates: <html lang={locale}>\n  const langAttr = t.jsxAttribute(\n    t.jsxIdentifier(\"lang\"),\n    t.jsxExpressionContainer(t.identifier(\"locale\")),\n  );\n\n  openingElement.attributes.push(langAttr);\n\n  logger.debug(\n    `Injected locale attribute into <html> element in component: ${component.name}`,\n  );\n\n  // Mark that this component needs locale destructured from the hook\n  state.componentsNeedingLocale.add(component.name);\n}\n\n/**\n * Inject translation hook into a component when it's done processing\n * Called when popping component from stack\n */\nexport function injectTranslationHook(\n  path: NodePath<\n    t.FunctionDeclaration | t.FunctionExpression | t.ArrowFunctionExpression\n  >,\n  component: ComponentEntry,\n  state: VisitorsInternalState,\n): void {\n  const needsLocale = state.componentsNeedingLocale.has(component.name);\n  const hashes = state.componentHashes.get(component.name);\n  if ((!hashes || hashes.length === 0) && !needsLocale) {\n    return; // No translations needed\n  }\n\n  if (component.isAsync) {\n    // Async component uses getServerTranslations\n    injectServerHook(path, hashes ?? [], needsLocale);\n    state.needsAsyncImport = true;\n  } else {\n    // Non-async component uses unified hook (useTranslation)\n    injectUnifiedHook(path, hashes ?? [], needsLocale);\n    state.needsUnifiedImport = true;\n  }\n}\n\n/**\n * Add translation imports at the top of the file\n * Called on Program exit after all components have been processed\n */\nfunction addTranslationImports(\n  programPath: NodePath<t.Program>,\n  state: VisitorsInternalState,\n): void {\n  // A file can have both async and non-async components!\n  if (state.needsAsyncImport) {\n    programPath.node.body.unshift(constructServerImport());\n  }\n  if (state.needsUnifiedImport) {\n    programPath.node.body.unshift(comstructUnifiedImport());\n  }\n}\n\n/**\n * Handle component function detection and state update\n */\nfunction processComponentFunction(\n  path: NodePath<\n    t.FunctionDeclaration | t.FunctionExpression | t.ArrowFunctionExpression\n  >,\n  state: VisitorsInternalState,\n): void {\n  if (!isReactComponent(path)) {\n    path.skip();\n    logger.debug(`Skipping non-React component: ${path.node.type}`);\n    return;\n  }\n\n  const componentName = inferComponentName(path);\n  if (!componentName) {\n    path.skip();\n    return;\n  }\n\n  // Store component info for later hook injection\n  if (!state.componentHashes.has(componentName)) {\n    state.componentHashes.set(componentName, []);\n  }\n\n  // Push component to stack with async info and path reference\n  const componentEntry: ComponentEntry = {\n    name: componentName,\n    isAsync: path.node.async,\n  };\n  state.componentsStack.push(componentEntry);\n  logger.debug(`Component ${JSON.stringify(componentEntry)} entered`);\n\n  path.setData(\"componentName\", componentName);\n  path.traverse(componentVisitors, { visitorState: state });\n  const component = state.componentsStack.pop();\n  if (component) {\n    injectTranslationHook(path, component, state);\n  }\n  // We have already traversed the path's children so the main traverse can skip it.\n  path.skip();\n}\n\nconst componentVisitors = {\n  // 1. Handle nested components. FunctionDeclaration|FunctionExpression|ArrowFunctionExpression unfortunately doesn't give the correct type signature for the path.\n  FunctionDeclaration(path: NodePath<t.FunctionDeclaration>) {\n    processComponentFunction(path, this.visitorState);\n  },\n  ArrowFunctionExpression(path: NodePath<t.ArrowFunctionExpression>) {\n    processComponentFunction(path, this.visitorState);\n  },\n  FunctionExpression(path: NodePath<t.FunctionExpression>) {\n    processComponentFunction(path, this.visitorState);\n  },\n  // 2. Fragments are separate from other JSX elements. Both <> and <Fragment> are the same AST node type.\n  JSXFragment(path: NodePath<t.JSXFragment>) {\n    // No attributes to translate on the fragment, so we only check if it has mixed content. If it doesn't, go ahead and its children will be checked.\n    // We also do not check for translation skip, because fragments are mostly used to make the bare text translatable.\n    // But if we want to support <Fragment data-lingo-skip>Text</Fragment> we should do it here.\n    processJSXElement(path, this.visitorState);\n  },\n\n  // Transform JSX elements with mixed content (text + expressions or nested elements)\n  JSXElement(path: NodePath<t.JSXElement>) {\n    translateAttributes(path.node, this.visitorState);\n\n    // Inject locale attribute into <html> elements for Next.js\n    injectHtmlLangAttribute(path.node, this.visitorState);\n\n    if (shouldSkipTranslationForElement(path.node)) {\n      path.skip();\n      return;\n    }\n    processJSXElement(path, this.visitorState);\n  },\n} satisfies TraverseOptions<{ visitorState: VisitorsInternalState }>;\n\nconst fileVisitors = {\n  // Handle static metadata exports: export const metadata = { ... }\n  ExportNamedDeclaration(path: NodePath<t.ExportNamedDeclaration>) {\n    // Check if the export is a metadata export and converts it to a function\n    const metadataState = processNextStaticMetadata(path, {\n      filePath: this.visitorState.filePath,\n    });\n\n    if (metadataState) {\n      updateWithMetadataState(this.visitorState, metadataState);\n    }\n  },\n\n  // All component function types share the same handler\n  FunctionDeclaration(path: NodePath<t.FunctionDeclaration>) {\n    const metadataState = processNextDynamicMetadata(path, {\n      filePath: this.visitorState.filePath,\n    });\n    if (metadataState) {\n      updateWithMetadataState(this.visitorState, metadataState);\n    }\n\n    // Otherwise, handle as component\n    processComponentFunction(path, this.visitorState);\n  },\n\n  // export const MyComponent = () => {}\n  ArrowFunctionExpression(path: NodePath<t.ArrowFunctionExpression>) {\n    processComponentFunction(path, this.visitorState);\n  },\n\n  // All these are considered function expressions\n  // const myFunction = function() {\n  //   return 'hello';\n  // };\n  //\n  // const myFunction2 = function namedFunc() {\n  //   return 'hello';\n  // };\n  //\n  // setTimeout(function() {\n  //   console.log('hello');\n  // }, 1000);\n  // While\n  // export default function() {}\n  // is not\n  FunctionExpression(path: NodePath<t.FunctionExpression>) {\n    processComponentFunction(path, this.visitorState);\n  },\n} satisfies TraverseOptions<{ visitorState: VisitorsInternalState }>;\n\n/**\n * Create Babel visitors for auto-translation (single-pass transformation)\n */\nconst programVisitor = {\n  Program: {\n    enter(path: NodePath<t.Program>) {\n      // We do the check on the loader level, but since they could be false positive, accepting the files we don't need to process, we do the check here as well.\n      if (this.visitorState.needsDirective && !hasUseI18nDirective(path)) {\n        path.skip();\n        return;\n      }\n\n      path.traverse(fileVisitors, {\n        visitorState: this.visitorState,\n      });\n    },\n\n    exit(path: NodePath<t.Program>) {\n      if (\n        this.visitorState.needsUnifiedImport ||\n        this.visitorState.needsAsyncImport\n      ) {\n        addTranslationImports(path, this.visitorState);\n      }\n    },\n  },\n} satisfies TraverseOptions<{ visitorState: VisitorsInternalState }>;\n\nexport function processFile(\n  ast: t.Node,\n  options: { relativeFilePath: string; needsDirective: boolean },\n) {\n  const state: VisitorsInternalState = {\n    needsDirective: options.needsDirective,\n    filePath: options.relativeFilePath,\n    newEntries: [],\n    componentsStack: [],\n    componentHashes: new Map<string, string[]>(),\n    needsUnifiedImport: false,\n    needsAsyncImport: false,\n    componentsNeedingLocale: new Set<string>(),\n  };\n\n  traverse(ast, programVisitor, undefined, { visitorState: state });\n\n  return state.newEntries;\n}\n"],"mappings":"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"}

package/build/plugin/transform/use-i18n.cjs

@@ -0,0 +1,8 @@
+
+//#region src/plugin/transform/use-i18n.ts
+const useI18n = "use i18n";
+const useI18nRegex = /* @__PURE__ */ new RegExp(`["']${useI18n}["']`);
+
+//#endregion
+exports.useI18n = useI18n;
+exports.useI18nRegex = useI18nRegex;

package/build/plugin/transform/use-i18n.mjs

@@ -0,0 +1,7 @@
+//#region src/plugin/transform/use-i18n.ts
+const useI18n = "use i18n";
+const useI18nRegex = /* @__PURE__ */ new RegExp(`["']${useI18n}["']`);
+
+//#endregion
+export { useI18n, useI18nRegex };
+//# sourceMappingURL=use-i18n.mjs.map

package/build/plugin/transform/use-i18n.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-i18n.mjs","names":[],"sources":["../../../src/plugin/transform/use-i18n.ts"],"sourcesContent":["export const useI18n = \"use i18n\";\nexport const useI18nRegex = new RegExp(`[\"']${useI18n}[\"']`);\n"],"mappings":";AAAA,MAAa,UAAU;AACvB,MAAa,+BAAe,IAAI,OAAO,OAAO,QAAQ,MAAM"}