@lingo.dev/compiler 0.1.0

package/build/plugin/transform/utils.cjs

@@ -0,0 +1,205 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_use_i18n = require('./use-i18n.cjs');
+const require_hash = require('../../utils/hash.cjs');
+let _babel_types = require("@babel/types");
+_babel_types = require_rolldown_runtime.__toESM(_babel_types);
+
+//#region src/plugin/transform/utils.ts
+const root = "@lingo.dev/compiler";
+/**
+* Normalize whitespace in translatable text.
+* - Collapses multiple spaces/tabs/newlines into a single space
+* - Preserves single spaces between words
+* - Trims leading and trailing whitespace
+*
+* Example: "Hello\n    world  \n  foo" → "Hello world foo"
+*/
+function normalizeWhitespace(text) {
+	return text.replace(/\s+/g, " ").trim();
+}
+/**
+* Escape literal angle brackets that are not part of ICU MessageFormat tags
+*/
+function escapeTextForICU(text) {
+	return text.replace(/'/g, "''").replace(/\{/g, "'{'").replace(/}/g, "'}'").replace(/</g, "'<'").replace(/#/g, "'#'");
+}
+/**
+* Detect if a function is a React component by checking if it returns JSX
+*/
+function isReactComponent(path) {
+	if (path.isArrowFunctionExpression()) {
+		const body = path.node.body;
+		if (body.type === "JSXElement" || body.type === "JSXFragment") return true;
+	}
+	let returnsJSX = false;
+	path.traverse({ ReturnStatement(returnPath) {
+		const argument = returnPath.node.argument;
+		if (argument && (argument.type === "JSXElement" || argument.type === "JSXFragment")) returnsJSX = true;
+	} });
+	return returnsJSX;
+}
+/**
+* Infer component name from various patterns
+*/
+function inferComponentName(path) {
+	if (path.node.id && path.node.id.name) return path.node.id.name;
+	const parent = path.parent;
+	if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") return parent.id.name;
+	if (parent.type === "ExportDefaultDeclaration") return "default";
+	return null;
+}
+/**
+* Check for 'use i18n' directive at program level
+*/
+function hasUseI18nDirective(program) {
+	return (program.node.directives || []).some((directive) => directive.value.value === require_use_i18n.useI18n);
+}
+function createTranslationEntry(type, text, context, filePath, line, column, overrides) {
+	const fullContext = {
+		...context,
+		filePath
+	};
+	return {
+		type,
+		sourceText: text,
+		context: fullContext,
+		hash: require_hash.generateTranslationHash(text, fullContext),
+		location: {
+			filePath,
+			line,
+			column
+		},
+		overrides: overrides && Object.keys(overrides).length > 0 ? overrides : void 0
+	};
+}
+/**
+* Create {t(hash, fallback, { var1, var2, tag0: (chunks) => <Tag>{chunks}</Tag> })} call expression
+*/
+function constructTranslationCall(hash, fallbackText, args) {
+	const callArguments = [_babel_types.stringLiteral(hash), _babel_types.stringLiteral(fallbackText)];
+	if (args) {
+		const properties = [];
+		for (const varName of args.variables) properties.push(_babel_types.objectProperty(_babel_types.identifier(varName), _babel_types.identifier(varName), false, true));
+		for (const [name, expr] of args.expressions) properties.push(_babel_types.objectProperty(_babel_types.identifier(name), expr, false, false));
+		for (const [tagName, element] of args.components) {
+			const renderFn = element.extra?.shouldTranslate === false ? _babel_types.arrowFunctionExpression([], element) : _babel_types.arrowFunctionExpression([_babel_types.identifier("chunks")], _babel_types.jsxElement(_babel_types.jsxOpeningElement(element.openingElement.name, element.openingElement.attributes, false), _babel_types.jsxClosingElement(element.closingElement?.name || element.openingElement.name), [_babel_types.jsxExpressionContainer(_babel_types.identifier("chunks"))], false));
+			properties.push(_babel_types.objectProperty(_babel_types.identifier(tagName), renderFn, false, false));
+		}
+		if (properties.length > 0) callArguments.push(_babel_types.objectExpression(properties));
+	}
+	return _babel_types.jsxExpressionContainer(_babel_types.callExpression(_babel_types.identifier("t"), callArguments));
+}
+/**
+* Check if a JSX element is self-closing or empty
+*/
+function isVoidElement(element) {
+	return element.openingElement.selfClosing || element.children.length === 0;
+}
+/**
+* Create unified import: import { useTranslation } from "@lingo.dev/compiler/react"
+*
+* Via conditional exports, this resolves to:
+* - server.ts in Server Components (React cache + use)
+* - index.ts in Client Components (Context)
+*/
+function comstructUnifiedImport() {
+	return _babel_types.importDeclaration([_babel_types.importSpecifier(_babel_types.identifier("useTranslation"), _babel_types.identifier("useTranslation"))], _babel_types.stringLiteral(`${root}/react`));
+}
+/**
+* Create import for server components: import { getServerTranslations } from "..."
+*/
+function constructServerImport() {
+	return _babel_types.importDeclaration([_babel_types.importSpecifier(_babel_types.identifier("getServerTranslations"), _babel_types.identifier("getServerTranslations"))], _babel_types.stringLiteral(`${root}/react/server`));
+}
+/**
+* Constructs a server translation hook call using provided configuration, server port, and hashes.
+* const { t } = await getServerTranslations({ ... })
+*
+* @param {Object} options - The input parameters.
+* @param {string[]} options.hashes - An array of hash strings related to translations.
+* @return {VariableDeclaration} - Returns an object containing the constructed translation hook code to be used on the server.
+*/
+function constructServerTranslationHookCall({ hashes, needsLocale = false }) {
+	const optionsProperties = [];
+	const hashArray = _babel_types.arrayExpression(hashes.map((hash) => _babel_types.stringLiteral(hash)));
+	optionsProperties.push(_babel_types.objectProperty(_babel_types.identifier("hashes"), hashArray));
+	const destructureProperties = [_babel_types.objectProperty(_babel_types.identifier("t"), _babel_types.identifier("t"), false, true)];
+	if (needsLocale) destructureProperties.push(_babel_types.objectProperty(_babel_types.identifier("locale"), _babel_types.identifier("locale"), false, true));
+	return _babel_types.variableDeclaration("const", [_babel_types.variableDeclarator(_babel_types.objectPattern(destructureProperties), _babel_types.awaitExpression(_babel_types.callExpression(_babel_types.identifier("getServerTranslations"), [_babel_types.objectExpression(optionsProperties)])))]);
+}
+/**
+* Inject unified `const t = useTranslation([...hashes])` at component start
+*
+* This hook works in BOTH Server and Client Components via conditional exports:
+* - In Server Components: loads server.ts (uses React cache() + use())
+* - In Client Components: loads index.ts (uses Context)
+*
+* This is the new default for non-async components!
+*
+* @param componentPath
+* @param hashes
+* @param needsLocale If true, destructures locale from hook: const { t, locale } = ...
+*/
+function injectUnifiedHook(componentPath, hashes, needsLocale = false) {
+	const body = componentPath.get("body");
+	let blockBody;
+	if (!body.isBlockStatement()) {
+		if (componentPath.isArrowFunctionExpression() && body.isExpression()) {
+			const returnStatement = _babel_types.returnStatement(body.node);
+			componentPath.node.body = _babel_types.blockStatement([returnStatement]);
+			blockBody = componentPath.get("body");
+		}
+	} else blockBody = body;
+	if (!blockBody) return;
+	const hashArray = _babel_types.arrayExpression(hashes.map((hash) => _babel_types.stringLiteral(hash)));
+	const pattern = _babel_types.objectPattern([_babel_types.objectProperty(_babel_types.identifier("t"), _babel_types.identifier("t"), false, true)]);
+	if (needsLocale) pattern.properties.push(_babel_types.objectProperty(_babel_types.identifier("locale"), _babel_types.identifier("locale"), false, true));
+	const hookCall = _babel_types.variableDeclaration("const", [_babel_types.variableDeclarator(pattern, _babel_types.callExpression(_babel_types.identifier("useTranslation"), [hashArray]))]);
+	blockBody.node.body.unshift(hookCall);
+}
+/**
+* Inject `const { t } = await getServerTranslations([...hashes])` at component start (Server Components)
+* Makes the component async if needed
+*
+* @param componentPath
+* @param hashes
+* @param needsLocale If true, destructures locale from hook: const { t, locale } = ...
+*/
+function injectServerHook(componentPath, hashes, needsLocale = false) {
+	const body = componentPath.get("body");
+	if (!body.isBlockStatement()) {
+		if (componentPath.isArrowFunctionExpression() && body.isExpression()) {
+			const returnStatement = _babel_types.returnStatement(body.node);
+			componentPath.node.body = _babel_types.blockStatement([returnStatement]);
+			componentPath.node.async = true;
+			const newBody = componentPath.get("body");
+			const serverCall$1 = constructServerTranslationHookCall({
+				hashes,
+				needsLocale
+			});
+			newBody.node.body.unshift(serverCall$1);
+		}
+		return;
+	}
+	if (!componentPath.node.async) componentPath.node.async = true;
+	const serverCall = constructServerTranslationHookCall({
+		hashes,
+		needsLocale
+	});
+	body.node.body.unshift(serverCall);
+}
+
+//#endregion
+exports.comstructUnifiedImport = comstructUnifiedImport;
+exports.constructServerImport = constructServerImport;
+exports.constructServerTranslationHookCall = constructServerTranslationHookCall;
+exports.constructTranslationCall = constructTranslationCall;
+exports.createTranslationEntry = createTranslationEntry;
+exports.escapeTextForICU = escapeTextForICU;
+exports.hasUseI18nDirective = hasUseI18nDirective;
+exports.inferComponentName = inferComponentName;
+exports.injectServerHook = injectServerHook;
+exports.injectUnifiedHook = injectUnifiedHook;
+exports.isReactComponent = isReactComponent;
+exports.isVoidElement = isVoidElement;
+exports.normalizeWhitespace = normalizeWhitespace;

package/build/plugin/transform/utils.mjs

@@ -0,0 +1,192 @@
+import { useI18n } from "./use-i18n.mjs";
+import { generateTranslationHash } from "../../utils/hash.mjs";
+import * as t from "@babel/types";
+
+//#region src/plugin/transform/utils.ts
+const root = "@lingo.dev/compiler";
+/**
+* Normalize whitespace in translatable text.
+* - Collapses multiple spaces/tabs/newlines into a single space
+* - Preserves single spaces between words
+* - Trims leading and trailing whitespace
+*
+* Example: "Hello\n    world  \n  foo" → "Hello world foo"
+*/
+function normalizeWhitespace(text) {
+	return text.replace(/\s+/g, " ").trim();
+}
+/**
+* Escape literal angle brackets that are not part of ICU MessageFormat tags
+*/
+function escapeTextForICU(text) {
+	return text.replace(/'/g, "''").replace(/\{/g, "'{'").replace(/}/g, "'}'").replace(/</g, "'<'").replace(/#/g, "'#'");
+}
+/**
+* Detect if a function is a React component by checking if it returns JSX
+*/
+function isReactComponent(path) {
+	if (path.isArrowFunctionExpression()) {
+		const body = path.node.body;
+		if (body.type === "JSXElement" || body.type === "JSXFragment") return true;
+	}
+	let returnsJSX = false;
+	path.traverse({ ReturnStatement(returnPath) {
+		const argument = returnPath.node.argument;
+		if (argument && (argument.type === "JSXElement" || argument.type === "JSXFragment")) returnsJSX = true;
+	} });
+	return returnsJSX;
+}
+/**
+* Infer component name from various patterns
+*/
+function inferComponentName(path) {
+	if (path.node.id && path.node.id.name) return path.node.id.name;
+	const parent = path.parent;
+	if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") return parent.id.name;
+	if (parent.type === "ExportDefaultDeclaration") return "default";
+	return null;
+}
+/**
+* Check for 'use i18n' directive at program level
+*/
+function hasUseI18nDirective(program) {
+	return (program.node.directives || []).some((directive) => directive.value.value === useI18n);
+}
+function createTranslationEntry(type, text, context, filePath, line, column, overrides) {
+	const fullContext = {
+		...context,
+		filePath
+	};
+	return {
+		type,
+		sourceText: text,
+		context: fullContext,
+		hash: generateTranslationHash(text, fullContext),
+		location: {
+			filePath,
+			line,
+			column
+		},
+		overrides: overrides && Object.keys(overrides).length > 0 ? overrides : void 0
+	};
+}
+/**
+* Create {t(hash, fallback, { var1, var2, tag0: (chunks) => <Tag>{chunks}</Tag> })} call expression
+*/
+function constructTranslationCall(hash, fallbackText, args) {
+	const callArguments = [t.stringLiteral(hash), t.stringLiteral(fallbackText)];
+	if (args) {
+		const properties = [];
+		for (const varName of args.variables) properties.push(t.objectProperty(t.identifier(varName), t.identifier(varName), false, true));
+		for (const [name, expr] of args.expressions) properties.push(t.objectProperty(t.identifier(name), expr, false, false));
+		for (const [tagName, element] of args.components) {
+			const renderFn = element.extra?.shouldTranslate === false ? t.arrowFunctionExpression([], element) : t.arrowFunctionExpression([t.identifier("chunks")], t.jsxElement(t.jsxOpeningElement(element.openingElement.name, element.openingElement.attributes, false), t.jsxClosingElement(element.closingElement?.name || element.openingElement.name), [t.jsxExpressionContainer(t.identifier("chunks"))], false));
+			properties.push(t.objectProperty(t.identifier(tagName), renderFn, false, false));
+		}
+		if (properties.length > 0) callArguments.push(t.objectExpression(properties));
+	}
+	return t.jsxExpressionContainer(t.callExpression(t.identifier("t"), callArguments));
+}
+/**
+* Check if a JSX element is self-closing or empty
+*/
+function isVoidElement(element) {
+	return element.openingElement.selfClosing || element.children.length === 0;
+}
+/**
+* Create unified import: import { useTranslation } from "@lingo.dev/compiler/react"
+*
+* Via conditional exports, this resolves to:
+* - server.ts in Server Components (React cache + use)
+* - index.ts in Client Components (Context)
+*/
+function comstructUnifiedImport() {
+	return t.importDeclaration([t.importSpecifier(t.identifier("useTranslation"), t.identifier("useTranslation"))], t.stringLiteral(`${root}/react`));
+}
+/**
+* Create import for server components: import { getServerTranslations } from "..."
+*/
+function constructServerImport() {
+	return t.importDeclaration([t.importSpecifier(t.identifier("getServerTranslations"), t.identifier("getServerTranslations"))], t.stringLiteral(`${root}/react/server`));
+}
+/**
+* Constructs a server translation hook call using provided configuration, server port, and hashes.
+* const { t } = await getServerTranslations({ ... })
+*
+* @param {Object} options - The input parameters.
+* @param {string[]} options.hashes - An array of hash strings related to translations.
+* @return {VariableDeclaration} - Returns an object containing the constructed translation hook code to be used on the server.
+*/
+function constructServerTranslationHookCall({ hashes, needsLocale = false }) {
+	const optionsProperties = [];
+	const hashArray = t.arrayExpression(hashes.map((hash) => t.stringLiteral(hash)));
+	optionsProperties.push(t.objectProperty(t.identifier("hashes"), hashArray));
+	const destructureProperties = [t.objectProperty(t.identifier("t"), t.identifier("t"), false, true)];
+	if (needsLocale) destructureProperties.push(t.objectProperty(t.identifier("locale"), t.identifier("locale"), false, true));
+	return t.variableDeclaration("const", [t.variableDeclarator(t.objectPattern(destructureProperties), t.awaitExpression(t.callExpression(t.identifier("getServerTranslations"), [t.objectExpression(optionsProperties)])))]);
+}
+/**
+* Inject unified `const t = useTranslation([...hashes])` at component start
+*
+* This hook works in BOTH Server and Client Components via conditional exports:
+* - In Server Components: loads server.ts (uses React cache() + use())
+* - In Client Components: loads index.ts (uses Context)
+*
+* This is the new default for non-async components!
+*
+* @param componentPath
+* @param hashes
+* @param needsLocale If true, destructures locale from hook: const { t, locale } = ...
+*/
+function injectUnifiedHook(componentPath, hashes, needsLocale = false) {
+	const body = componentPath.get("body");
+	let blockBody;
+	if (!body.isBlockStatement()) {
+		if (componentPath.isArrowFunctionExpression() && body.isExpression()) {
+			const returnStatement = t.returnStatement(body.node);
+			componentPath.node.body = t.blockStatement([returnStatement]);
+			blockBody = componentPath.get("body");
+		}
+	} else blockBody = body;
+	if (!blockBody) return;
+	const hashArray = t.arrayExpression(hashes.map((hash) => t.stringLiteral(hash)));
+	const pattern = t.objectPattern([t.objectProperty(t.identifier("t"), t.identifier("t"), false, true)]);
+	if (needsLocale) pattern.properties.push(t.objectProperty(t.identifier("locale"), t.identifier("locale"), false, true));
+	const hookCall = t.variableDeclaration("const", [t.variableDeclarator(pattern, t.callExpression(t.identifier("useTranslation"), [hashArray]))]);
+	blockBody.node.body.unshift(hookCall);
+}
+/**
+* Inject `const { t } = await getServerTranslations([...hashes])` at component start (Server Components)
+* Makes the component async if needed
+*
+* @param componentPath
+* @param hashes
+* @param needsLocale If true, destructures locale from hook: const { t, locale } = ...
+*/
+function injectServerHook(componentPath, hashes, needsLocale = false) {
+	const body = componentPath.get("body");
+	if (!body.isBlockStatement()) {
+		if (componentPath.isArrowFunctionExpression() && body.isExpression()) {
+			const returnStatement = t.returnStatement(body.node);
+			componentPath.node.body = t.blockStatement([returnStatement]);
+			componentPath.node.async = true;
+			const newBody = componentPath.get("body");
+			const serverCall$1 = constructServerTranslationHookCall({
+				hashes,
+				needsLocale
+			});
+			newBody.node.body.unshift(serverCall$1);
+		}
+		return;
+	}
+	if (!componentPath.node.async) componentPath.node.async = true;
+	const serverCall = constructServerTranslationHookCall({
+		hashes,
+		needsLocale
+	});
+	body.node.body.unshift(serverCall);
+}
+
+//#endregion
+export { comstructUnifiedImport, constructServerImport, constructServerTranslationHookCall, constructTranslationCall, createTranslationEntry, escapeTextForICU, hasUseI18nDirective, inferComponentName, injectServerHook, injectUnifiedHook, isReactComponent, isVoidElement, normalizeWhitespace };
+//# sourceMappingURL=utils.mjs.map

package/build/plugin/transform/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":["callArguments: t.Expression[]","properties: t.ObjectProperty[]","blockBody: NodePath<t.BlockStatement> | undefined","serverCall"],"sources":["../../../src/plugin/transform/utils.ts"],"sourcesContent":["import type { TranslationEntry } from \"../../types\";\nimport type { NodePath } from \"@babel/traverse\";\nimport type { VariableDeclaration } from \"@babel/types\";\nimport * as t from \"@babel/types\";\nimport { generateTranslationHash } from \"../../utils/hash\";\nimport { useI18n } from \"./use-i18n\";\n\ntype TranslationEntryByType = {\n  [T in TranslationEntry as T[\"type\"]]: T;\n};\n\nconst root = \"@lingo.dev/compiler\";\n// TODO (AleksandrSl 28/11/2025): See jsx-content.ts in the old compiler for future improvements.\n\n/**\n * Normalize whitespace in translatable text.\n * - Collapses multiple spaces/tabs/newlines into a single space\n * - Preserves single spaces between words\n * - Trims leading and trailing whitespace\n *\n * Example: \"Hello\\n    world  \\n  foo\" → \"Hello world foo\"\n */\nexport function normalizeWhitespace(text: string): string {\n  return text\n    .replace(/\\s+/g, \" \") // Collapse all whitespace sequences to single space\n    .trim(); // Remove leading/trailing whitespace\n}\n\n/**\n * Escape literal angle brackets that are not part of ICU MessageFormat tags\n */\nexport function escapeTextForICU(text: string): string {\n  // Related spec - https://unicode-org.github.io/icu/userguide/format_parse/messages/#quotingescaping\n  return text\n    .replace(/'/g, \"''\")\n    .replace(/\\{/g, \"'{'\")\n    .replace(/}/g, \"'}'\")\n    .replace(/</g, \"'<'\")\n    .replace(/#/g, \"'#'\");\n}\n\n/**\n * Detect if a function is a React component by checking if it returns JSX\n */\nexport function isReactComponent(\n  path: NodePath<\n    t.FunctionDeclaration | t.FunctionExpression | t.ArrowFunctionExpression\n  >,\n): boolean {\n  // Check for arrow function with JSX expression body: () => <div>...</div>\n  if (path.isArrowFunctionExpression()) {\n    const body = path.node.body;\n    if (body.type === \"JSXElement\" || body.type === \"JSXFragment\") {\n      return true;\n    }\n  }\n\n  // Babel traverses with DFS so we get the innermost function return first if any.\n  // But if at least one function returns JSX I guess we should transform the whole function.\n  // It's a weird corner case.\n\n  // Check for explicit return statements with JSX\n  // We could also check for the first JSX?\n  let returnsJSX = false;\n  path.traverse({\n    ReturnStatement(returnPath) {\n      const argument = returnPath.node.argument;\n      if (\n        argument &&\n        (argument.type === \"JSXElement\" || argument.type === \"JSXFragment\")\n      ) {\n        returnsJSX = true;\n      }\n    },\n  });\n\n  // ts doesn't see what happens inside path.traverse, and erroneously narrows returnsJsx to false\n  return returnsJSX as boolean;\n}\n\n/**\n * Infer component name from various patterns\n */\nexport function inferComponentName(path: NodePath<any>): string | null {\n  // Named function: function MyComponent() {}\n  if (path.node.id && path.node.id.name) {\n    return path.node.id.name;\n  }\n\n  // Variable declaration: const MyComponent = () => {}\n  const parent = path.parent;\n  if (parent.type === \"VariableDeclarator\" && parent.id.type === \"Identifier\") {\n    return parent.id.name;\n  }\n\n  // TODO (AleksandrSl 25/11/2025): It should support export const $NAME$\n  // Export: export default function() {}\n  if (parent.type === \"ExportDefaultDeclaration\") {\n    return \"default\";\n  }\n\n  return null;\n}\n\n/**\n * Check for 'use i18n' directive at program level\n */\nexport function hasUseI18nDirective(program: NodePath<t.Program>): boolean {\n  const directives = program.node.directives || [];\n  return directives.some(\n    (directive: t.Directive) => directive.value.value === useI18n,\n  );\n}\n\nexport function createTranslationEntry<T extends keyof TranslationEntryByType>(\n  type: T,\n  text: string,\n  context: Omit<TranslationEntryByType[T][\"context\"], \"filePath\">,\n  filePath: string,\n  line?: number,\n  column?: number,\n  overrides?: Record<string, string>,\n): TranslationEntryByType[T] {\n  const fullContext = { ...context, filePath };\n  const hash = generateTranslationHash(text, fullContext);\n\n  return {\n    type,\n    sourceText: text,\n    context: fullContext,\n    hash,\n    location: {\n      filePath,\n      line,\n      column,\n    },\n    overrides:\n      overrides && Object.keys(overrides).length > 0 ? overrides : undefined,\n    // Seems like the only approach without the cast is function overloads, which are noisy. The type cast is not that bad since it's inside the function.\n  } as TranslationEntryByType[T];\n}\n\n/**\n * Create {t(hash, fallback, { var1, var2, tag0: (chunks) => <Tag>{chunks}</Tag> })} call expression\n */\nexport function constructTranslationCall(\n  hash: string,\n  fallbackText: string,\n  args?: {\n    variables: string[];\n    expressions: Map<string, t.Expression>;\n    components: Map<string, t.JSXElement>;\n  },\n): t.JSXExpressionContainer {\n  const callArguments: t.Expression[] = [\n    t.stringLiteral(hash),\n    t.stringLiteral(fallbackText),\n  ];\n\n  if (args) {\n    const properties: t.ObjectProperty[] = [];\n\n    // Add variable properties (shorthand)\n    for (const varName of args.variables) {\n      properties.push(\n        t.objectProperty(\n          t.identifier(varName),\n          t.identifier(varName),\n          false,\n          true, // shorthand\n        ),\n      );\n    }\n\n    for (const [name, expr] of args.expressions) {\n      properties.push(t.objectProperty(t.identifier(name), expr, false, false));\n    }\n\n    // Add component renderer functions\n    for (const [tagName, element] of args.components) {\n      const renderFn =\n        element.extra?.shouldTranslate === false\n          ? // Even when doing: tagName: () => <Element />, we need a function for formatjs to work.\n            t.arrowFunctionExpression([], element)\n          : // Create: tagName: (chunks) => <Element>{chunks}</Element>\n            t.arrowFunctionExpression(\n              [t.identifier(\"chunks\")],\n              t.jsxElement(\n                t.jsxOpeningElement(\n                  element.openingElement.name,\n                  element.openingElement.attributes,\n                  false,\n                ),\n                t.jsxClosingElement(\n                  element.closingElement?.name || element.openingElement.name,\n                ),\n                [t.jsxExpressionContainer(t.identifier(\"chunks\"))],\n                false,\n              ),\n            );\n\n      properties.push(\n        t.objectProperty(t.identifier(tagName), renderFn, false, false),\n      );\n    }\n\n    if (properties.length > 0) {\n      callArguments.push(t.objectExpression(properties));\n    }\n  }\n\n  return t.jsxExpressionContainer(\n    t.callExpression(t.identifier(\"t\"), callArguments),\n  );\n}\n\n/**\n * Check if a JSX element is self-closing or empty\n */\nexport function isVoidElement(element: t.JSXElement): boolean {\n  return element.openingElement.selfClosing || element.children.length === 0;\n}\n\n/**\n * Create unified import: import { useTranslation } from \"@lingo.dev/compiler/react\"\n *\n * Via conditional exports, this resolves to:\n * - server.ts in Server Components (React cache + use)\n * - index.ts in Client Components (Context)\n */\nexport function comstructUnifiedImport(): t.ImportDeclaration {\n  return t.importDeclaration(\n    [\n      t.importSpecifier(\n        t.identifier(\"useTranslation\"),\n        t.identifier(\"useTranslation\"),\n      ),\n    ],\n    t.stringLiteral(`${root}/react`),\n  );\n}\n\n/**\n * Create import for server components: import { getServerTranslations } from \"...\"\n */\nexport function constructServerImport(): t.ImportDeclaration {\n  return t.importDeclaration(\n    [\n      t.importSpecifier(\n        t.identifier(\"getServerTranslations\"),\n        t.identifier(\"getServerTranslations\"),\n      ),\n    ],\n    t.stringLiteral(`${root}/react/server`),\n  );\n}\n\n/**\n * Constructs a server translation hook call using provided configuration, server port, and hashes.\n * const { t } = await getServerTranslations({ ... })\n *\n * @param {Object} options - The input parameters.\n * @param {string[]} options.hashes - An array of hash strings related to translations.\n * @return {VariableDeclaration} - Returns an object containing the constructed translation hook code to be used on the server.\n */\nexport function constructServerTranslationHookCall({\n  hashes,\n  needsLocale = false,\n}: {\n  hashes: string[];\n  needsLocale?: boolean;\n}): VariableDeclaration {\n  const optionsProperties = [];\n\n  const hashArray = t.arrayExpression(\n    hashes.map((hash) => t.stringLiteral(hash)),\n  );\n  optionsProperties.push(t.objectProperty(t.identifier(\"hashes\"), hashArray));\n\n  const destructureProperties = [\n    t.objectProperty(\n      t.identifier(\"t\"),\n      t.identifier(\"t\"),\n      false,\n      true, // shorthand\n    ),\n  ];\n\n  if (needsLocale) {\n    destructureProperties.push(\n      t.objectProperty(\n        t.identifier(\"locale\"),\n        t.identifier(\"locale\"),\n        false,\n        true, // shorthand\n      ),\n    );\n  }\n\n  return t.variableDeclaration(\"const\", [\n    t.variableDeclarator(\n      t.objectPattern(destructureProperties),\n      t.awaitExpression(\n        t.callExpression(t.identifier(\"getServerTranslations\"), [\n          t.objectExpression(optionsProperties),\n        ]),\n      ),\n    ),\n  ]);\n}\n\n/**\n * Inject unified `const t = useTranslation([...hashes])` at component start\n *\n * This hook works in BOTH Server and Client Components via conditional exports:\n * - In Server Components: loads server.ts (uses React cache() + use())\n * - In Client Components: loads index.ts (uses Context)\n *\n * This is the new default for non-async components!\n *\n * @param componentPath\n * @param hashes\n * @param needsLocale If true, destructures locale from hook: const { t, locale } = ...\n */\nexport function injectUnifiedHook(\n  componentPath: NodePath<\n    t.FunctionDeclaration | t.FunctionExpression | t.ArrowFunctionExpression\n  >,\n  hashes: string[],\n  needsLocale: boolean = false,\n): void {\n  const body = componentPath.get(\"body\");\n\n  let blockBody: NodePath<t.BlockStatement> | undefined;\n  // Handle arrow functions with expression bodies: () => <jsx>\n  // Convert to block statement: () => { const t = ...; return <jsx>; }\n  if (!body.isBlockStatement()) {\n    if (componentPath.isArrowFunctionExpression() && body.isExpression()) {\n      const returnStatement = t.returnStatement(body.node as t.Expression);\n      componentPath.node.body = t.blockStatement([returnStatement]);\n      // Re-get the body after conversion\n      blockBody = componentPath.get(\"body\") as NodePath<t.BlockStatement>;\n    }\n  } else {\n    blockBody = body;\n  }\n\n  if (!blockBody) {\n    return;\n  }\n\n  const hashArray = t.arrayExpression(\n    hashes.map((hash) => t.stringLiteral(hash)),\n  );\n\n  const pattern = t.objectPattern([\n    t.objectProperty(t.identifier(\"t\"), t.identifier(\"t\"), false, true),\n  ]);\n  if (needsLocale) {\n    pattern.properties.push(\n      t.objectProperty(\n        t.identifier(\"locale\"),\n        t.identifier(\"locale\"),\n        false,\n        true,\n      ),\n    );\n  }\n\n  const hookCall = t.variableDeclaration(\"const\", [\n    t.variableDeclarator(\n      pattern,\n      t.callExpression(t.identifier(\"useTranslation\"), [hashArray]),\n    ),\n  ]);\n\n  blockBody.node.body.unshift(hookCall);\n}\n\n/**\n * Inject `const { t } = await getServerTranslations([...hashes])` at component start (Server Components)\n * Makes the component async if needed\n *\n * @param componentPath\n * @param hashes\n * @param needsLocale If true, destructures locale from hook: const { t, locale } = ...\n */\nexport function injectServerHook(\n  componentPath: NodePath<\n    t.FunctionDeclaration | t.FunctionExpression | t.ArrowFunctionExpression\n  >,\n  hashes: string[],\n  needsLocale: boolean = false,\n): void {\n  const body = componentPath.get(\"body\");\n\n  // Handle arrow functions with expression bodies: () => <jsx>\n  // Convert to block statement: async () => { const { t } = await ...; return <jsx>; }\n  if (!body.isBlockStatement()) {\n    if (componentPath.isArrowFunctionExpression() && body.isExpression()) {\n      const returnStatement = t.returnStatement(body.node as t.Expression);\n      componentPath.node.body = t.blockStatement([returnStatement]);\n      componentPath.node.async = true;\n      // Re-get the body after conversion\n      const newBody = componentPath.get(\"body\") as NodePath<t.BlockStatement>;\n\n      // Create: const { t } = await getServerTranslations({ ... })\n      const serverCall = constructServerTranslationHookCall({\n        hashes,\n        needsLocale,\n      });\n\n      newBody.node.body.unshift(serverCall);\n    }\n    return;\n  }\n\n  if (!componentPath.node.async) {\n    componentPath.node.async = true;\n  }\n\n  // Create: const { t } = await getServerTranslations({ ... })\n  const serverCall = constructServerTranslationHookCall({\n    hashes,\n    needsLocale,\n  });\n\n  body.node.body.unshift(serverCall);\n}\n"],"mappings":"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"}

package/build/plugin/unplugin.cjs

@@ -0,0 +1,188 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_logger = require('../utils/logger.cjs');
+const require_config_factory = require('../utils/config-factory.cjs');
+const require_manager = require('../metadata/manager.cjs');
+const require_translation_server = require('../translation-server/translation-server.cjs');
+const require_build_translator = require('./build-translator.cjs');
+const require_cleanup = require('./cleanup.cjs');
+const require_use_i18n = require('./transform/use-i18n.cjs');
+const require_index = require('./transform/index.cjs');
+const require_code_generator = require('../virtual/code-generator.cjs');
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path);
+let fs = require("fs");
+fs = require_rolldown_runtime.__toESM(fs);
+let unplugin = require("unplugin");
+
+//#region src/plugin/unplugin.ts
+let translationServer;
+const PLUGIN_NAME = "lingo-compiler";
+function tryLocalOrReturnVirtual(config, fileName, virtualName) {
+	const customPath = path.default.join(config.sourceRoot, config.lingoDir, fileName);
+	if (fs.default.existsSync(customPath)) return customPath;
+	return virtualName;
+}
+/**
+* Single source of truth for virtual modules
+* Each entry defines both resolver (import path → virtual ID) and loader (virtual ID → code)
+*
+* If customFileCheck is defined, the specified file will be first searched for, and if not found virtual module will be used.
+*/
+const virtualModules = {
+	"@lingo.dev/compiler/virtual/config": {
+		virtualId: "\0virtual:lingo-config",
+		loader: (config) => require_code_generator.generateConfigModule(config),
+		customFileCheck: void 0
+	},
+	"@lingo.dev/compiler/virtual/locale/server": {
+		virtualId: "\0virtual:locale-resolver.server",
+		loader: (config) => require_code_generator.generateServerLocaleModule(config),
+		customFileCheck: "locale-resolver.server.ts"
+	},
+	"@lingo.dev/compiler/virtual/locale/client": {
+		virtualId: "\0virtual:locale-resolver.client",
+		loader: (config) => require_code_generator.generateClientLocaleModule(config),
+		customFileCheck: "locale-resolver.client.ts"
+	}
+};
+const virtualModulesResolvers = Object.fromEntries(Object.entries(virtualModules).map(([importPath, module$1]) => [importPath, (config) => module$1.customFileCheck ? tryLocalOrReturnVirtual(config, module$1.customFileCheck, module$1.virtualId) : module$1.virtualId]));
+const virtualModulesLoaders = Object.fromEntries(Object.values(virtualModules).map((value) => [value.virtualId, value.loader]));
+/**
+* Universal plugin for Lingo.dev compiler
+* Supports Vite, Webpack
+*/
+const lingoUnplugin = (0, unplugin.createUnplugin)((options) => {
+	const config = require_config_factory.createLingoConfig(options);
+	const isDev = config.environment === "development";
+	const startPort = config.dev.translationServerStartPort;
+	let webpackMode;
+	const getMetadataPath$1 = () => {
+		return require_manager.getMetadataPath(webpackMode ? {
+			...config,
+			environment: webpackMode
+		} : config);
+	};
+	async function startServer() {
+		const server = await require_translation_server.startTranslationServer({
+			startPort,
+			onError: (err) => {
+				require_logger.logger.error("Translation server error:", err);
+			},
+			onReady: (port) => {
+				require_logger.logger.info(`Translation server started successfully on port: ${port}`);
+			},
+			config
+		});
+		config.dev.translationServerUrl = server.getUrl();
+		require_cleanup.registerCleanupOnCurrentProcess({ asyncCleanup: async () => {
+			await translationServer.stop();
+		} });
+		return server;
+	}
+	return {
+		name: PLUGIN_NAME,
+		enforce: "pre",
+		vite: {
+			config() {
+				return { optimizeDeps: { exclude: ["@lingo.dev/compiler"] } };
+			},
+			async buildStart() {
+				const metadataFilePath = getMetadataPath$1();
+				require_manager.cleanupExistingMetadata(metadataFilePath);
+				require_cleanup.registerCleanupOnCurrentProcess({ cleanup: () => require_manager.cleanupExistingMetadata(metadataFilePath) });
+				if (isDev && !translationServer) translationServer = await startServer();
+			},
+			async buildEnd() {
+				const metadataFilePath = getMetadataPath$1();
+				if (!isDev) try {
+					await require_build_translator.processBuildTranslations({
+						config,
+						publicOutputPath: "public/translations",
+						metadataFilePath
+					});
+				} catch (error) {
+					require_logger.logger.error("Build-time translation processing failed:", error);
+				}
+			}
+		},
+		webpack(compiler) {
+			webpackMode = compiler.options.mode === "development" ? "development" : "production";
+			const metadataFilePath = getMetadataPath$1();
+			config.environment = webpackMode;
+			compiler.hooks.initialize.tap(PLUGIN_NAME, () => {
+				require_manager.cleanupExistingMetadata(metadataFilePath);
+				require_cleanup.registerCleanupOnCurrentProcess({ cleanup: () => require_manager.cleanupExistingMetadata(metadataFilePath) });
+			});
+			compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, async () => {
+				if (webpackMode === "development" && !translationServer) translationServer = await startServer();
+			});
+			compiler.hooks.additionalPass.tapPromise(PLUGIN_NAME, async () => {
+				if (webpackMode === "production") try {
+					await require_build_translator.processBuildTranslations({
+						config,
+						publicOutputPath: "public/translations",
+						metadataFilePath
+					});
+				} catch (error) {
+					require_logger.logger.error("Build-time translation processing failed:", error);
+					throw error;
+				}
+			});
+			compiler.hooks.shutdown.tapPromise(PLUGIN_NAME, async () => {
+				require_manager.cleanupExistingMetadata(metadataFilePath);
+				await translationServer?.stop();
+			});
+		},
+		resolveId(id) {
+			const handler = virtualModulesResolvers[id];
+			if (handler) return handler(config);
+			return null;
+		},
+		load: {
+			filter: { id: /virtual:/ },
+			handler(id) {
+				const handler = virtualModulesLoaders[id];
+				if (handler) return handler(config);
+				return null;
+			}
+		},
+		transform: {
+			filter: {
+				id: {
+					include: [/\.[tj]sx$/],
+					exclude: /node_modules/
+				},
+				code: config.useDirective ? require_use_i18n.useI18nRegex : void 0
+			},
+			async handler(code, id) {
+				try {
+					const result = require_index.transformComponent({
+						code,
+						filePath: id,
+						config
+					});
+					if (!result.transformed) {
+						require_logger.logger.debug(`No transformation needed for ${id}`);
+						return null;
+					}
+					const metadataManager = new require_manager.MetadataManager(getMetadataPath$1());
+					if (result.newEntries && result.newEntries.length > 0) {
+						await metadataManager.saveMetadataWithEntries(result.newEntries);
+						require_logger.logger.debug(`Found ${result.newEntries.length} translatable text(s) in ${id}`);
+					}
+					require_logger.logger.debug(`Returning transformed code for ${id}`);
+					return {
+						code: result.code,
+						map: result.map
+					};
+				} catch (error) {
+					require_logger.logger.error(`Transform error in ${id}:`, error);
+					return null;
+				}
+			}
+		}
+	};
+});
+
+//#endregion
+exports.lingoUnplugin = lingoUnplugin;

package/build/plugin/unplugin.d.cts

@@ -0,0 +1,8 @@
+import { PartialLingoConfig } from "../types.cjs";
+import "unplugin";
+
+//#region src/plugin/unplugin.d.ts
+type LingoPluginOptions = PartialLingoConfig;
+//#endregion
+export { LingoPluginOptions };
+//# sourceMappingURL=unplugin.d.cts.map

package/build/plugin/unplugin.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unplugin.d.cts","names":[],"sources":["../../src/plugin/unplugin.ts"],"sourcesContent":[],"mappings":";;;;KA6BY,kBAAA,GAAqB"}

package/build/plugin/unplugin.d.mts

@@ -0,0 +1,8 @@
+import { PartialLingoConfig } from "../types.mjs";
+import "unplugin";
+
+//#region src/plugin/unplugin.d.ts
+type LingoPluginOptions = PartialLingoConfig;
+//#endregion
+export { LingoPluginOptions };
+//# sourceMappingURL=unplugin.d.mts.map

package/build/plugin/unplugin.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unplugin.d.mts","names":[],"sources":["../../src/plugin/unplugin.ts"],"sourcesContent":[],"mappings":";;;;KA6BY,kBAAA,GAAqB"}