@lingo.dev/compiler 0.1.0

package/build/plugin/next.mjs

@@ -0,0 +1,222 @@
+import { __require } from "../_virtual/rolldown_runtime.mjs";
+import { logger } from "../utils/logger.mjs";
+import { createLingoConfig } from "../utils/config-factory.mjs";
+import { cleanupExistingMetadata, getMetadataPath } from "../metadata/manager.mjs";
+import { startOrGetTranslationServer } from "../translation-server/translation-server.mjs";
+import { processBuildTranslations } from "./build-translator.mjs";
+import { registerCleanupOnCurrentProcess } from "./cleanup.mjs";
+import { useI18nRegex } from "./transform/use-i18n.mjs";
+
+//#region src/plugin/next.ts
+function loaders({ lingoConfig, metadataFilePath, translationServerUrl }) {
+	const common = {
+		sourceRoot: lingoConfig.sourceRoot,
+		lingoDir: lingoConfig.lingoDir,
+		sourceLocale: lingoConfig.sourceLocale
+	};
+	const compilerLoader = {
+		loader: "@lingo.dev/compiler/next-compiler-loader",
+		options: {
+			...common,
+			useDirective: lingoConfig.useDirective,
+			metadataFilePath
+		}
+	};
+	const configLoader = {
+		loader: "@lingo.dev/compiler/next-config-loader",
+		options: {
+			...common,
+			dev: {
+				translationServerUrl,
+				...lingoConfig.dev
+			}
+		}
+	};
+	const localeServerLoader = {
+		loader: "@lingo.dev/compiler/next-locale-server-loader",
+		options: {
+			...common,
+			localePersistence: lingoConfig.localePersistence
+		}
+	};
+	const localeClientLoader = {
+		loader: "@lingo.dev/compiler/next-locale-client-loader",
+		options: {
+			...common,
+			localePersistence: lingoConfig.localePersistence
+		}
+	};
+	return {
+		compiler: {
+			turbopack: {
+				pattern: "*.{tsx,jsx}",
+				config: {
+					condition: { content: lingoConfig.useDirective ? useI18nRegex : void 0 },
+					loaders: [compilerLoader]
+				}
+			},
+			webpack: {
+				enforce: "pre",
+				test: /\.(tsx|jsx)$/i,
+				exclude: /node_modules/,
+				use: [compilerLoader]
+			}
+		},
+		devConfig: translationServerUrl ? {
+			turbopack: {
+				pattern: "**/virtual/config.mjs",
+				config: { loaders: [configLoader] }
+			},
+			webpack: {
+				enforce: "pre",
+				test: /virtual\/config\.mjs$/i,
+				use: [configLoader]
+			}
+		} : {},
+		localeServer: {
+			turbopack: {
+				pattern: "**/virtual/locale/server.mjs",
+				config: { loaders: [localeServerLoader] }
+			},
+			webpack: {
+				enforce: "pre",
+				test: /virtual\/locale[\\/]server\.mjs$/i,
+				use: [localeServerLoader]
+			}
+		},
+		localeClient: {
+			turbopack: {
+				pattern: "**/virtual/locale/client.mjs",
+				config: { loaders: [localeClientLoader] }
+			},
+			webpack: {
+				enforce: "pre",
+				test: /virtual\/locale[\\/]client\.mjs$/i,
+				use: [localeClientLoader]
+			}
+		}
+	};
+}
+/**
+* Check if Next.js supports stable turbopack config (Next.js 16+)
+*/
+function hasStableTurboConfig() {
+	try {
+		const nextPackage = __require("next/package.json");
+		return parseInt(nextPackage.version.split(".")[0], 10) >= 16;
+	} catch {
+		return false;
+	}
+}
+function getTurbopackConfig(userConfig) {
+	return (hasStableTurboConfig() ? userConfig?.turbopack?.rules : userConfig?.experimental?.turbo) || {};
+}
+/**
+* Merge Turbopack rules without mutating original
+*/
+function mergeTurbopackRules(existingRules, newRules) {
+	const mergedRules = { ...existingRules };
+	for (const newRule of newRules) {
+		if (!newRule) continue;
+		const { pattern, config } = newRule;
+		if (mergedRules[pattern]) if (Array.isArray(mergedRules[pattern])) mergedRules[pattern] = [...mergedRules[pattern], config];
+		else mergedRules[pattern] = [mergedRules[pattern], config];
+		else mergedRules[pattern] = config;
+	}
+	return mergedRules;
+}
+function isMainRunner() {
+	return !process.env.NEXT_PRIVATE_BUILD_WORKER && !process.env.IS_NEXT_WORKER && !process.env.NEXT_PRIVATE_WORKER;
+}
+async function withLingo(nextConfig = {}, lingoOptions) {
+	const lingoConfig = createLingoConfig(lingoOptions);
+	let metadataFilePath = getMetadataPath(lingoConfig);
+	const isDev = lingoConfig.environment === "development";
+	logger.debug(`Initializing Lingo.dev compiler. Is dev mode: ${isDev}. Is main runner: ${isMainRunner()}`);
+	if (isDev && !process.env.LINGO_TRANSLATION_SERVER_URL) {
+		const translationServer = await startOrGetTranslationServer({
+			startPort: lingoConfig.dev.translationServerStartPort,
+			onError: (err) => {
+				logger.error("Translation server error:", err);
+			},
+			onReady: (port) => {
+				logger.info(`Translation server started successfully on port: ${port}`);
+			},
+			config: lingoConfig
+		});
+		process.env.LINGO_TRANSLATION_SERVER_URL = translationServer.url;
+		if (translationServer.server) registerCleanupOnCurrentProcess({ asyncCleanup: async () => {
+			await translationServer.server.stop();
+		} });
+	}
+	const translationServerUrl = process.env.LINGO_TRANSLATION_SERVER_URL;
+	if (isMainRunner()) {
+		cleanupExistingMetadata(metadataFilePath);
+		registerCleanupOnCurrentProcess({ cleanup: () => {
+			cleanupExistingMetadata(metadataFilePath);
+		} });
+	}
+	const existingTurbopackConfig = getTurbopackConfig(nextConfig);
+	let mergedRules = mergeTurbopackRules(existingTurbopackConfig.rules ?? {}, Object.values(loaders({
+		lingoConfig,
+		metadataFilePath,
+		translationServerUrl
+	})).map((rules) => rules.turbopack));
+	const mergedResolveAlias = { ...existingTurbopackConfig.resolveAlias };
+	let turbopackConfig;
+	if (hasStableTurboConfig()) turbopackConfig = { turbopack: {
+		...nextConfig.turbopack,
+		rules: mergedRules,
+		resolveAlias: mergedResolveAlias
+	} };
+	else turbopackConfig = { experimental: {
+		...nextConfig.experimental,
+		turbo: {
+			...nextConfig.experimental?.turbo,
+			rules: mergedRules,
+			resolveAlias: mergedResolveAlias
+		}
+	} };
+	const runAfterProductionCompile = async ({ distDir, projectDir }) => {
+		if (typeof nextConfig.compiler?.runAfterProductionCompile === "function") await nextConfig.compiler.runAfterProductionCompile({
+			distDir,
+			projectDir
+		});
+		logger.info("Running post-build translation generation...");
+		logger.info(`Build mode: Using metadata file: ${metadataFilePath}`);
+		try {
+			await processBuildTranslations({
+				config: lingoConfig,
+				publicOutputPath: distDir,
+				metadataFilePath
+			});
+		} catch (error) {
+			logger.error("Translation generation failed:", error);
+			throw error;
+		}
+	};
+	const webpack = (config, options) => {
+		let modifiedConfig = config;
+		if (typeof nextConfig.webpack === "function") modifiedConfig = nextConfig.webpack(config, options);
+		const lingoRules = Object.values(loaders({
+			lingoConfig,
+			metadataFilePath,
+			translationServerUrl
+		})).map((rules) => rules.webpack).filter(Boolean);
+		modifiedConfig.module.rules.unshift(...lingoRules);
+		return modifiedConfig;
+	};
+	return {
+		...nextConfig,
+		...turbopackConfig,
+		compiler: {
+			...nextConfig.compiler,
+			runAfterProductionCompile
+		},
+		webpack
+	};
+}
+
+//#endregion
+export { withLingo };
+//# sourceMappingURL=next.mjs.map

package/build/plugin/next.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.mjs","names":["turbopackConfig: Partial<NextConfig>","webpack: NextJsWebpackConfig"],"sources":["../../src/plugin/next.ts"],"sourcesContent":["import type { NextConfig } from \"next\";\nimport type {\n  NextJsWebpackConfig,\n  TurbopackOptions,\n  WebpackConfigContext,\n} from \"next/dist/server/config-shared\";\nimport { createLingoConfig } from \"../utils/config-factory\";\nimport { logger } from \"../utils/logger\";\nimport type { LingoConfig, PartialLingoConfig } from \"../types\";\nimport { processBuildTranslations } from \"./build-translator\";\nimport { startOrGetTranslationServer } from \"../translation-server/translation-server\";\nimport { cleanupExistingMetadata, getMetadataPath } from \"../metadata/manager\";\nimport { registerCleanupOnCurrentProcess } from \"./cleanup\";\nimport { useI18nRegex } from \"./transform/use-i18n\";\n\nexport type LingoNextPluginOptions = PartialLingoConfig;\n\ntype RuleKey = \"compiler\" | \"devConfig\" | \"localeServer\" | \"localeClient\";\n\nfunction loaders({\n  lingoConfig,\n  metadataFilePath,\n  translationServerUrl,\n}: {\n  lingoConfig: LingoConfig;\n  metadataFilePath: string;\n  translationServerUrl?: string;\n}): Record<RuleKey, { turbopack?: any; webpack?: any }> {\n  const common = {\n    sourceRoot: lingoConfig.sourceRoot,\n    lingoDir: lingoConfig.lingoDir,\n    sourceLocale: lingoConfig.sourceLocale,\n  };\n\n  // TODO (AleksandrSl 14/12/2025): Type options.\n  const compilerLoader = {\n    loader: \"@lingo.dev/compiler/next-compiler-loader\",\n    options: {\n      ...common,\n      useDirective: lingoConfig.useDirective,\n      metadataFilePath,\n    },\n  };\n\n  const configLoader = {\n    loader: \"@lingo.dev/compiler/next-config-loader\",\n    options: {\n      ...common,\n      dev: {\n        translationServerUrl,\n        ...lingoConfig.dev,\n      },\n    },\n  };\n  const localeServerLoader = {\n    loader: \"@lingo.dev/compiler/next-locale-server-loader\",\n    options: {\n      ...common,\n      localePersistence: lingoConfig.localePersistence,\n    },\n  };\n\n  const localeClientLoader = {\n    loader: \"@lingo.dev/compiler/next-locale-client-loader\",\n    options: {\n      ...common,\n      localePersistence: lingoConfig.localePersistence,\n    },\n  };\n\n  return {\n    compiler: {\n      turbopack: {\n        pattern: \"*.{tsx,jsx}\",\n        config: {\n          condition: {\n            content: lingoConfig.useDirective ? useI18nRegex : undefined,\n          },\n          loaders: [compilerLoader],\n        },\n      },\n      webpack: {\n        enforce: \"pre\",\n        test: /\\.(tsx|jsx)$/i,\n        exclude: /node_modules/,\n        use: [compilerLoader],\n      },\n    },\n\n    devConfig: translationServerUrl\n      ? {\n          turbopack: {\n            pattern: \"**/virtual/config.mjs\",\n            config: {\n              loaders: [configLoader],\n            },\n          },\n          webpack: {\n            enforce: \"pre\",\n            test: /virtual\\/config\\.mjs$/i,\n            use: [configLoader],\n          },\n        }\n      : {},\n\n    localeServer: {\n      turbopack: {\n        pattern: \"**/virtual/locale/server.mjs\",\n        config: {\n          loaders: [localeServerLoader],\n        },\n      },\n      webpack: {\n        enforce: \"pre\",\n        test: /virtual\\/locale[\\\\/]server\\.mjs$/i,\n        use: [localeServerLoader],\n      },\n    },\n\n    localeClient: {\n      turbopack: {\n        pattern: \"**/virtual/locale/client.mjs\",\n        config: {\n          loaders: [localeClientLoader],\n        },\n      },\n      webpack: {\n        enforce: \"pre\",\n        test: /virtual\\/locale[\\\\/]client\\.mjs$/i,\n        use: [localeClientLoader],\n      },\n    },\n  };\n}\n\n/**\n * Check if Next.js supports stable turbopack config (Next.js 16+)\n */\nfunction hasStableTurboConfig(): boolean {\n  try {\n    const nextPackage = require(\"next/package.json\");\n    const majorVersion = parseInt(nextPackage.version.split(\".\")[0], 10);\n    return majorVersion >= 16;\n  } catch {\n    return false;\n  }\n}\n\nfunction getTurbopackConfig(userConfig: NextConfig): TurbopackOptions {\n  return (\n    (hasStableTurboConfig()\n      ? userConfig?.turbopack?.rules\n      : // @ts-expect-error - experimental.turbo for Next.js <16\n        userConfig?.experimental?.turbo) || {}\n  );\n}\n\n/**\n * Merge Turbopack rules without mutating original\n */\nfunction mergeTurbopackRules(\n  existingRules: Record<string, any>,\n  newRules: ({ pattern: string; config: any } | undefined)[],\n): Record<string, any> {\n  const mergedRules = { ...existingRules };\n\n  for (const newRule of newRules) {\n    if (!newRule) continue;\n    const { pattern, config } = newRule;\n\n    if (mergedRules[pattern]) {\n      if (Array.isArray(mergedRules[pattern])) {\n        mergedRules[pattern] = [...mergedRules[pattern], config];\n      } else {\n        mergedRules[pattern] = [mergedRules[pattern], config];\n      }\n    } else {\n      mergedRules[pattern] = config;\n    }\n  }\n\n  return mergedRules;\n}\n\n// Next read config several times. Once in the main runner,\n// and ~ twice in the build workers which cannot get the config otherwise, because it's not serializable.\n// Workers start in separate processed by get most of the env from the main loader\nfunction isMainRunner() {\n  return (\n    !process.env.NEXT_PRIVATE_BUILD_WORKER &&\n    !process.env.IS_NEXT_WORKER &&\n    !process.env.NEXT_PRIVATE_WORKER\n  );\n}\n\nexport async function withLingo(\n  nextConfig: NextConfig = {},\n  lingoOptions: LingoNextPluginOptions,\n): Promise<NextConfig> {\n  const lingoConfig = createLingoConfig(lingoOptions);\n  let metadataFilePath = getMetadataPath(lingoConfig);\n  const isDev = lingoConfig.environment === \"development\";\n\n  logger.debug(\n    `Initializing Lingo.dev compiler. Is dev mode: ${isDev}. Is main runner: ${isMainRunner()}`,\n  );\n\n  // TODO (AleksandrSl 12/12/2025): Add API keys validation too, so we can log it nicely.\n\n  // Try to start up the translation server once.\n  // We have two barriers, a simple one here and a more complex one inside the startTranslationServer which doesn't start the server if it can find one running.\n  // We do not use isMainRunner here, because we need to start the server as early as possible, so the loaders get the translation server url. The main runner in dev mode runs after a dev server process is started.\n  if (isDev && !process.env.LINGO_TRANSLATION_SERVER_URL) {\n    const translationServer = await startOrGetTranslationServer({\n      startPort: lingoConfig.dev.translationServerStartPort,\n      onError: (err) => {\n        logger.error(\"Translation server error:\", err);\n      },\n      onReady: (port) => {\n        logger.info(`Translation server started successfully on port: ${port}`);\n      },\n      config: lingoConfig,\n    });\n    process.env.LINGO_TRANSLATION_SERVER_URL = translationServer.url;\n    if (translationServer.server) {\n      // We start the server in the same process, so we should be fine without any sync cleanup. Server should be killed with the process.\n      registerCleanupOnCurrentProcess({\n        asyncCleanup: async () => {\n          await translationServer.server.stop();\n        },\n      });\n    }\n  }\n\n  const translationServerUrl = process.env.LINGO_TRANSLATION_SERVER_URL;\n\n  if (isMainRunner()) {\n    // We need to cleaup the file only once, to avoid having extra translation introduced into the build, or old translation to pile up.\n    cleanupExistingMetadata(metadataFilePath);\n\n    registerCleanupOnCurrentProcess({\n      cleanup: () => {\n        cleanupExistingMetadata(metadataFilePath);\n      },\n    });\n  }\n\n  const existingTurbopackConfig = getTurbopackConfig(nextConfig);\n  let mergedRules = mergeTurbopackRules(\n    existingTurbopackConfig.rules ?? {},\n    Object.values(\n      loaders({ lingoConfig, metadataFilePath, translationServerUrl }),\n    ).map((rules) => rules.turbopack),\n  );\n\n  const existingResolveAlias = existingTurbopackConfig.resolveAlias;\n  const mergedResolveAlias = {\n    ...existingResolveAlias,\n    // TODO (AleksandrSl 08/12/2025): Describe what have to be done to support custom resolvers\n  };\n\n  let turbopackConfig: Partial<NextConfig>;\n  if (hasStableTurboConfig()) {\n    turbopackConfig = {\n      turbopack: {\n        ...nextConfig.turbopack, // Preserve existing turbopack options\n        rules: mergedRules,\n        resolveAlias: mergedResolveAlias,\n      },\n    };\n  } else {\n    turbopackConfig = {\n      experimental: {\n        ...nextConfig.experimental, // Preserve ALL experimental options\n        // @ts-expect-error - turbo for Next.js <16\n        turbo: {\n          // @ts-expect-error - turbo for Next.js <16\n          ...nextConfig.experimental?.turbo, // Preserve existing turbo options\n          rules: mergedRules,\n          resolveAlias: mergedResolveAlias,\n        },\n      },\n    };\n  }\n\n  const runAfterProductionCompile = async ({\n    distDir,\n    projectDir,\n  }: {\n    distDir: string;\n    projectDir: string;\n  }) => {\n    if (typeof nextConfig.compiler?.runAfterProductionCompile === \"function\") {\n      await nextConfig.compiler.runAfterProductionCompile({\n        distDir,\n        projectDir,\n      });\n    }\n\n    logger.info(\"Running post-build translation generation...\");\n    logger.info(`Build mode: Using metadata file: ${metadataFilePath}`);\n\n    try {\n      await processBuildTranslations({\n        config: lingoConfig,\n        publicOutputPath: distDir,\n        metadataFilePath,\n      });\n    } catch (error) {\n      logger.error(\"Translation generation failed:\", error);\n      throw error;\n    }\n  };\n\n  const webpack: NextJsWebpackConfig = (\n    config: any,\n    options: WebpackConfigContext,\n  ) => {\n    // Apply user's webpack config first if it exists\n    let modifiedConfig = config;\n    if (typeof nextConfig.webpack === \"function\") {\n      modifiedConfig = nextConfig.webpack(config, options);\n    }\n\n    const lingoRules = Object.values(\n      loaders({ lingoConfig, metadataFilePath, translationServerUrl }),\n    )\n      .map((rules) => rules.webpack)\n      .filter(Boolean);\n\n    // I tried using plugin from unplugin, but with all the loaders stuff it works poorly.\n    // Failing with weird errors which appear on the later compilations, probably something with the cache and virtual modules\n    modifiedConfig.module.rules.unshift(...lingoRules);\n\n    return modifiedConfig;\n  };\n\n  return {\n    ...nextConfig,\n    ...turbopackConfig,\n    compiler: {\n      ...nextConfig.compiler,\n      runAfterProductionCompile,\n    },\n    webpack,\n  };\n}\n"],"mappings":"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"}

package/build/plugin/transform/babel-compat.cjs

@@ -0,0 +1,13 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let _babel_traverse = require("@babel/traverse");
+_babel_traverse = require_rolldown_runtime.__toESM(_babel_traverse);
+let _babel_generator = require("@babel/generator");
+_babel_generator = require_rolldown_runtime.__toESM(_babel_generator);
+
+//#region src/plugin/transform/babel-compat.ts
+const traverse = _babel_traverse.default.default ?? _babel_traverse.default;
+const generate = _babel_generator.default.default ?? _babel_generator.default;
+
+//#endregion
+exports.generate = generate;
+exports.traverse = traverse;

package/build/plugin/transform/babel-compat.mjs

@@ -0,0 +1,10 @@
+import traverseDefault from "@babel/traverse";
+import generateDefault from "@babel/generator";
+
+//#region src/plugin/transform/babel-compat.ts
+const traverse = traverseDefault.default ?? traverseDefault;
+const generate = generateDefault.default ?? generateDefault;
+
+//#endregion
+export { generate, traverse };
+//# sourceMappingURL=babel-compat.mjs.map

package/build/plugin/transform/babel-compat.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-compat.mjs","names":["traverse: typeof traverseDefault","generate: typeof generateDefault"],"sources":["../../../src/plugin/transform/babel-compat.ts"],"sourcesContent":["import traverseDefault from \"@babel/traverse\";\nimport generateDefault from \"@babel/generator\";\n\n// Handle ESM/CJS interop - these packages may export differently\nconst traverse: typeof traverseDefault =\n  // @ts-expect-error - Handle both default and named exports\n  traverseDefault.default ?? traverseDefault;\nconst generate: typeof generateDefault =\n  // @ts-expect-error - Handle both default and named exports\n  generateDefault.default ?? generateDefault;\n\nexport { traverse, generate };\n"],"mappings":";;;;AAIA,MAAMA,WAEJ,gBAAgB,WAAW;AAC7B,MAAMC,WAEJ,gBAAgB,WAAW"}

package/build/plugin/transform/index.cjs

@@ -0,0 +1,44 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_logger = require('../../utils/logger.cjs');
+const require_babel_compat = require('./babel-compat.cjs');
+const require_process_file = require('./process-file.cjs');
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path);
+let _babel_parser = require("@babel/parser");
+_babel_parser = require_rolldown_runtime.__toESM(_babel_parser);
+
+//#region src/plugin/transform/index.ts
+/**
+* Transform component code to inject translation calls
+*/
+function transformComponent({ code, filePath, config }) {
+	const relativeFilePath = path.default.relative(path.default.resolve(config.sourceRoot), filePath).split(path.default.sep).join("/");
+	try {
+		const ast = _babel_parser.parse(code, {
+			sourceType: "module",
+			plugins: ["jsx", "typescript"]
+		});
+		require_logger.logger.debug(`Transforming ${filePath}`);
+		const translationEntries = require_process_file.processFile(ast, {
+			relativeFilePath,
+			needsDirective: config.useDirective
+		});
+		const output = require_babel_compat.generate(ast, { sourceMaps: true }, code);
+		require_logger.logger.debug(`Transformed ${filePath}. Code: ${output.code}`);
+		return {
+			code: output.code,
+			map: output.map,
+			newEntries: translationEntries,
+			transformed: translationEntries.length > 0
+		};
+	} catch (error) {
+		require_logger.logger.error(`Failed to transform ${filePath}:`, error);
+		return {
+			code,
+			transformed: false
+		};
+	}
+}
+
+//#endregion
+exports.transformComponent = transformComponent;

package/build/plugin/transform/index.mjs

@@ -0,0 +1,42 @@
+import { logger } from "../../utils/logger.mjs";
+import { generate } from "./babel-compat.mjs";
+import { processFile } from "./process-file.mjs";
+import path from "path";
+import * as parser from "@babel/parser";
+
+//#region src/plugin/transform/index.ts
+/**
+* Transform component code to inject translation calls
+*/
+function transformComponent({ code, filePath, config }) {
+	const relativeFilePath = path.relative(path.resolve(config.sourceRoot), filePath).split(path.sep).join("/");
+	try {
+		const ast = parser.parse(code, {
+			sourceType: "module",
+			plugins: ["jsx", "typescript"]
+		});
+		logger.debug(`Transforming ${filePath}`);
+		const translationEntries = processFile(ast, {
+			relativeFilePath,
+			needsDirective: config.useDirective
+		});
+		const output = generate(ast, { sourceMaps: true }, code);
+		logger.debug(`Transformed ${filePath}. Code: ${output.code}`);
+		return {
+			code: output.code,
+			map: output.map,
+			newEntries: translationEntries,
+			transformed: translationEntries.length > 0
+		};
+	} catch (error) {
+		logger.error(`Failed to transform ${filePath}:`, error);
+		return {
+			code,
+			transformed: false
+		};
+	}
+}
+
+//#endregion
+export { transformComponent };
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/plugin/transform/index.ts"],"sourcesContent":["import * as parser from \"@babel/parser\";\nimport path from \"path\";\nimport type { LingoConfig, TranslationEntry } from \"../../types\";\nimport { processFile } from \"./process-file\";\nimport { logger } from \"../../utils/logger\";\nimport { generate } from \"./babel-compat\";\n\nexport interface TransformResult {\n  code: string;\n  map?: any;\n  newEntries?: TranslationEntry[];\n  transformed: boolean;\n}\n\nexport interface BabelTransformOptions {\n  code: string;\n  filePath: string;\n  config: LingoConfig;\n}\n\n/**\n * Transform component code to inject translation calls\n */\nexport function transformComponent({\n  code,\n  filePath,\n  config,\n}: BabelTransformOptions): TransformResult {\n  // Get relative file path for consistent hashing\n  const relativeFilePath = path\n    .relative(path.resolve(config.sourceRoot), filePath)\n    .split(path.sep)\n    // '/' is used as a cross-platform path separator\n    .join(\"/\");\n\n  try {\n    const ast = parser.parse(code, {\n      sourceType: \"module\",\n      plugins: [\"jsx\", \"typescript\"],\n    });\n\n    logger.debug(`Transforming ${filePath}`);\n\n    const translationEntries = processFile(ast, {\n      relativeFilePath,\n      needsDirective: config.useDirective,\n    });\n\n    const output = generate(\n      ast,\n      {\n        sourceMaps: true,\n      },\n      code,\n    );\n\n    logger.debug(`Transformed ${filePath}. Code: ${output.code}`);\n\n    return {\n      code: output.code,\n      map: output.map,\n      newEntries: translationEntries,\n      transformed: translationEntries.length > 0,\n    };\n  } catch (error) {\n    // TODO (AleksandrSl 08/12/2025): Should also log the message\n    logger.error(`Failed to transform ${filePath}:`, error);\n    // Return original code on error\n    return {\n      code,\n      transformed: false,\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;AAuBA,SAAgB,mBAAmB,EACjC,MACA,UACA,UACyC;CAEzC,MAAM,mBAAmB,KACtB,SAAS,KAAK,QAAQ,OAAO,WAAW,EAAE,SAAS,CACnD,MAAM,KAAK,IAAI,CAEf,KAAK,IAAI;AAEZ,KAAI;EACF,MAAM,MAAM,OAAO,MAAM,MAAM;GAC7B,YAAY;GACZ,SAAS,CAAC,OAAO,aAAa;GAC/B,CAAC;AAEF,SAAO,MAAM,gBAAgB,WAAW;EAExC,MAAM,qBAAqB,YAAY,KAAK;GAC1C;GACA,gBAAgB,OAAO;GACxB,CAAC;EAEF,MAAM,SAAS,SACb,KACA,EACE,YAAY,MACb,EACD,KACD;AAED,SAAO,MAAM,eAAe,SAAS,UAAU,OAAO,OAAO;AAE7D,SAAO;GACL,MAAM,OAAO;GACb,KAAK,OAAO;GACZ,YAAY;GACZ,aAAa,mBAAmB,SAAS;GAC1C;UACM,OAAO;AAEd,SAAO,MAAM,uBAAuB,SAAS,IAAI,MAAM;AAEvD,SAAO;GACL;GACA,aAAa;GACd"}

package/build/plugin/transform/metadata.cjs

@@ -0,0 +1,142 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_utils = require('./utils.cjs');
+let _babel_types = require("@babel/types");
+_babel_types = require_rolldown_runtime.__toESM(_babel_types);
+
+//#region src/plugin/transform/metadata.ts
+/**
+* Transforms Next.js metadata object to use t() calls. See https://nextjs.org/docs/app/getting-started/metadata-and-og-images for docs on next metadata.
+*/
+/**
+* Whitelist of metadata fields that should be translated.
+* Other fields (like technical configurations, URLs, etc.) are left unchanged.
+*/
+const TRANSLATABLE_METADATA_FIELDS = new Set([
+	"title",
+	"description",
+	"title.template",
+	"title.default",
+	"openGraph.title",
+	"openGraph.description",
+	"openGraph.images[*].alt",
+	"twitter.title",
+	"twitter.description",
+	"twitter.images[*].alt",
+	"appleWebApp.title"
+]);
+const NEXT_METADATA_EXPORT_NAME = "metadata";
+const NEXT_GENERATE_METADATA_FUNCTION_NAME = "generateMetadata";
+/**
+* Check if a field path matches a pattern with array indices.
+* For example: "openGraph.images[0].alt" matches "openGraph.images[*].alt"
+*/
+function matchesArrayPattern(fieldPath, pattern) {
+	return fieldPath.replace(/\[\d+]/g, "[*]") === pattern;
+}
+/**
+* Check if a metadata field path should be translated
+*/
+function isTranslatableMetadataField(fieldPath) {
+	if (TRANSLATABLE_METADATA_FIELDS.has(fieldPath)) return true;
+	for (const pattern of TRANSLATABLE_METADATA_FIELDS) if (pattern.includes("[*]") && matchesArrayPattern(fieldPath, pattern)) return true;
+	return false;
+}
+function isNextGenerateMetadataFunction(path) {
+	if (path.node.id?.name === NEXT_GENERATE_METADATA_FUNCTION_NAME) {
+		const parent = path.parent;
+		if (parent.type === "ExportNamedDeclaration" || parent.type === "Program") return true;
+	}
+}
+function getNextMetadataObjectOrNull(path) {
+	const declaration = path.node.declaration;
+	if (!declaration || declaration.type !== "VariableDeclaration") return null;
+	const declarator = declaration.declarations[0];
+	if (!declarator || declarator.id.type !== "Identifier") return null;
+	if (declarator.id.name === NEXT_METADATA_EXPORT_NAME && declarator.init) return declarator.init;
+}
+/**
+* Recursively transforms metadata object properties to use t() calls
+*/
+function transformMetadataObject(objectExpression, state, entries, parentPath = "") {
+	for (const prop of objectExpression.properties) {
+		if (prop.type !== "ObjectProperty") continue;
+		let keyName = null;
+		if (prop.key.type === "Identifier") keyName = prop.key.name;
+		else if (prop.key.type === "StringLiteral") keyName = prop.key.value;
+		if (!keyName) continue;
+		const fieldPath = parentPath ? `${parentPath}.${keyName}` : keyName;
+		const shouldTranslate = isTranslatableMetadataField(fieldPath);
+		if (prop.value.type === "StringLiteral" && shouldTranslate) {
+			const text = prop.value.value;
+			const entry = require_utils.createTranslationEntry("metadata", text, { fieldPath }, state.filePath, prop.value.loc?.start.line, prop.value.loc?.start.column);
+			entries.push(entry);
+			prop.value = _babel_types.callExpression(_babel_types.identifier("t"), [_babel_types.stringLiteral(entry.hash), _babel_types.stringLiteral(text)]);
+		} else if (prop.value.type === "TemplateLiteral" && shouldTranslate) {
+			if (prop.value.expressions.length === 0 && prop.value.quasis.length === 1) {
+				const staticValue = prop.value.quasis[0].value.cooked;
+				if (staticValue) {
+					const entry = require_utils.createTranslationEntry("metadata", staticValue, { fieldPath }, state.filePath, prop.value.loc?.start.line, prop.value.loc?.start.column);
+					entries.push(entry);
+					prop.value = _babel_types.callExpression(_babel_types.identifier("t"), [_babel_types.stringLiteral(entry.hash), _babel_types.stringLiteral(staticValue)]);
+				}
+			}
+		} else if (prop.value.type === "ObjectExpression") transformMetadataObject(prop.value, state, entries, fieldPath);
+		else if (prop.value.type === "ArrayExpression") prop.value.elements.forEach((element, index) => {
+			if (element && element.type === "ObjectExpression") transformMetadataObject(element, state, entries, `${fieldPath}[${index}]`);
+		});
+	}
+}
+/**
+* Transform existing generateMetadata function to add translations
+*/
+function transformMetadataFunction(path, state) {
+	const body = path.get("body");
+	if (!body.isBlockStatement()) return null;
+	let metadataReturn = void 0;
+	body.traverse({ ReturnStatement(returnPath) {
+		if (!metadataReturn) metadataReturn = returnPath;
+	} });
+	if (!(0, _babel_types.isReturnStatement)(metadataReturn) || !metadataReturn.node.argument) return null;
+	if (!(0, _babel_types.isObjectExpression)(metadataReturn.node.argument)) return null;
+	const entries = [];
+	const metadataObject = metadataReturn.node.argument;
+	transformMetadataObject(metadataObject, state, entries);
+	if (entries.length === 0) return null;
+	if (!path.node.async) path.node.async = true;
+	const serverCall = require_utils.constructServerTranslationHookCall({ hashes: entries.map((e) => e.hash) });
+	body.node.body.unshift(serverCall);
+	return {
+		needsAsyncImport: true,
+		newEntries: entries
+	};
+}
+/**
+* Process static metadata export
+* Only converts to function if there are translatable strings
+*/
+function processNextStaticMetadata(path, state) {
+	const metadataObject = getNextMetadataObjectOrNull(path);
+	if (!metadataObject || metadataObject.type !== "ObjectExpression") return null;
+	const clonedObject = _babel_types.cloneNode(metadataObject, true);
+	const entries = [];
+	transformMetadataObject(clonedObject, state, entries);
+	if (entries.length === 0) return null;
+	const serverCall = require_utils.constructServerTranslationHookCall({ hashes: entries.map((e) => e.hash) });
+	const generateMetadataFunction = _babel_types.functionDeclaration(_babel_types.identifier(NEXT_GENERATE_METADATA_FUNCTION_NAME), [], _babel_types.blockStatement([serverCall, _babel_types.returnStatement(clonedObject)]), false, true);
+	path.replaceWith(_babel_types.exportNamedDeclaration(generateMetadataFunction, []));
+	path.skip();
+	return {
+		needsAsyncImport: true,
+		newEntries: entries
+	};
+}
+function processNextDynamicMetadata(path, state) {
+	if (!isNextGenerateMetadataFunction(path)) return null;
+	const newState = transformMetadataFunction(path, state);
+	path.skip();
+	return newState;
+}
+
+//#endregion
+exports.processNextDynamicMetadata = processNextDynamicMetadata;
+exports.processNextStaticMetadata = processNextStaticMetadata;

package/build/plugin/transform/metadata.mjs

@@ -0,0 +1,141 @@
+import { constructServerTranslationHookCall, createTranslationEntry } from "./utils.mjs";
+import * as t from "@babel/types";
+import { isObjectExpression, isReturnStatement } from "@babel/types";
+
+//#region src/plugin/transform/metadata.ts
+/**
+* Transforms Next.js metadata object to use t() calls. See https://nextjs.org/docs/app/getting-started/metadata-and-og-images for docs on next metadata.
+*/
+/**
+* Whitelist of metadata fields that should be translated.
+* Other fields (like technical configurations, URLs, etc.) are left unchanged.
+*/
+const TRANSLATABLE_METADATA_FIELDS = new Set([
+	"title",
+	"description",
+	"title.template",
+	"title.default",
+	"openGraph.title",
+	"openGraph.description",
+	"openGraph.images[*].alt",
+	"twitter.title",
+	"twitter.description",
+	"twitter.images[*].alt",
+	"appleWebApp.title"
+]);
+const NEXT_METADATA_EXPORT_NAME = "metadata";
+const NEXT_GENERATE_METADATA_FUNCTION_NAME = "generateMetadata";
+/**
+* Check if a field path matches a pattern with array indices.
+* For example: "openGraph.images[0].alt" matches "openGraph.images[*].alt"
+*/
+function matchesArrayPattern(fieldPath, pattern) {
+	return fieldPath.replace(/\[\d+]/g, "[*]") === pattern;
+}
+/**
+* Check if a metadata field path should be translated
+*/
+function isTranslatableMetadataField(fieldPath) {
+	if (TRANSLATABLE_METADATA_FIELDS.has(fieldPath)) return true;
+	for (const pattern of TRANSLATABLE_METADATA_FIELDS) if (pattern.includes("[*]") && matchesArrayPattern(fieldPath, pattern)) return true;
+	return false;
+}
+function isNextGenerateMetadataFunction(path) {
+	if (path.node.id?.name === NEXT_GENERATE_METADATA_FUNCTION_NAME) {
+		const parent = path.parent;
+		if (parent.type === "ExportNamedDeclaration" || parent.type === "Program") return true;
+	}
+}
+function getNextMetadataObjectOrNull(path) {
+	const declaration = path.node.declaration;
+	if (!declaration || declaration.type !== "VariableDeclaration") return null;
+	const declarator = declaration.declarations[0];
+	if (!declarator || declarator.id.type !== "Identifier") return null;
+	if (declarator.id.name === NEXT_METADATA_EXPORT_NAME && declarator.init) return declarator.init;
+}
+/**
+* Recursively transforms metadata object properties to use t() calls
+*/
+function transformMetadataObject(objectExpression, state, entries, parentPath = "") {
+	for (const prop of objectExpression.properties) {
+		if (prop.type !== "ObjectProperty") continue;
+		let keyName = null;
+		if (prop.key.type === "Identifier") keyName = prop.key.name;
+		else if (prop.key.type === "StringLiteral") keyName = prop.key.value;
+		if (!keyName) continue;
+		const fieldPath = parentPath ? `${parentPath}.${keyName}` : keyName;
+		const shouldTranslate = isTranslatableMetadataField(fieldPath);
+		if (prop.value.type === "StringLiteral" && shouldTranslate) {
+			const text = prop.value.value;
+			const entry = createTranslationEntry("metadata", text, { fieldPath }, state.filePath, prop.value.loc?.start.line, prop.value.loc?.start.column);
+			entries.push(entry);
+			prop.value = t.callExpression(t.identifier("t"), [t.stringLiteral(entry.hash), t.stringLiteral(text)]);
+		} else if (prop.value.type === "TemplateLiteral" && shouldTranslate) {
+			if (prop.value.expressions.length === 0 && prop.value.quasis.length === 1) {
+				const staticValue = prop.value.quasis[0].value.cooked;
+				if (staticValue) {
+					const entry = createTranslationEntry("metadata", staticValue, { fieldPath }, state.filePath, prop.value.loc?.start.line, prop.value.loc?.start.column);
+					entries.push(entry);
+					prop.value = t.callExpression(t.identifier("t"), [t.stringLiteral(entry.hash), t.stringLiteral(staticValue)]);
+				}
+			}
+		} else if (prop.value.type === "ObjectExpression") transformMetadataObject(prop.value, state, entries, fieldPath);
+		else if (prop.value.type === "ArrayExpression") prop.value.elements.forEach((element, index) => {
+			if (element && element.type === "ObjectExpression") transformMetadataObject(element, state, entries, `${fieldPath}[${index}]`);
+		});
+	}
+}
+/**
+* Transform existing generateMetadata function to add translations
+*/
+function transformMetadataFunction(path, state) {
+	const body = path.get("body");
+	if (!body.isBlockStatement()) return null;
+	let metadataReturn = void 0;
+	body.traverse({ ReturnStatement(returnPath) {
+		if (!metadataReturn) metadataReturn = returnPath;
+	} });
+	if (!isReturnStatement(metadataReturn) || !metadataReturn.node.argument) return null;
+	if (!isObjectExpression(metadataReturn.node.argument)) return null;
+	const entries = [];
+	const metadataObject = metadataReturn.node.argument;
+	transformMetadataObject(metadataObject, state, entries);
+	if (entries.length === 0) return null;
+	if (!path.node.async) path.node.async = true;
+	const serverCall = constructServerTranslationHookCall({ hashes: entries.map((e) => e.hash) });
+	body.node.body.unshift(serverCall);
+	return {
+		needsAsyncImport: true,
+		newEntries: entries
+	};
+}
+/**
+* Process static metadata export
+* Only converts to function if there are translatable strings
+*/
+function processNextStaticMetadata(path, state) {
+	const metadataObject = getNextMetadataObjectOrNull(path);
+	if (!metadataObject || metadataObject.type !== "ObjectExpression") return null;
+	const clonedObject = t.cloneNode(metadataObject, true);
+	const entries = [];
+	transformMetadataObject(clonedObject, state, entries);
+	if (entries.length === 0) return null;
+	const serverCall = constructServerTranslationHookCall({ hashes: entries.map((e) => e.hash) });
+	const generateMetadataFunction = t.functionDeclaration(t.identifier(NEXT_GENERATE_METADATA_FUNCTION_NAME), [], t.blockStatement([serverCall, t.returnStatement(clonedObject)]), false, true);
+	path.replaceWith(t.exportNamedDeclaration(generateMetadataFunction, []));
+	path.skip();
+	return {
+		needsAsyncImport: true,
+		newEntries: entries
+	};
+}
+function processNextDynamicMetadata(path, state) {
+	if (!isNextGenerateMetadataFunction(path)) return null;
+	const newState = transformMetadataFunction(path, state);
+	path.skip();
+	return newState;
+}
+
+//#endregion
+export { processNextDynamicMetadata, processNextStaticMetadata };
+//# sourceMappingURL=metadata.mjs.map