@lingo.dev/compiler 0.1.0

package/build/plugin/unplugin.mjs

@@ -0,0 +1,186 @@
+import { logger } from "../utils/logger.mjs";
+import { createLingoConfig } from "../utils/config-factory.mjs";
+import { MetadataManager, cleanupExistingMetadata, getMetadataPath } from "../metadata/manager.mjs";
+import { startTranslationServer } from "../translation-server/translation-server.mjs";
+import { processBuildTranslations } from "./build-translator.mjs";
+import { registerCleanupOnCurrentProcess } from "./cleanup.mjs";
+import { useI18nRegex } from "./transform/use-i18n.mjs";
+import { transformComponent } from "./transform/index.mjs";
+import { generateClientLocaleModule, generateConfigModule, generateServerLocaleModule } from "../virtual/code-generator.mjs";
+import path from "path";
+import fs from "fs";
+import { createUnplugin } from "unplugin";
+
+//#region src/plugin/unplugin.ts
+let translationServer;
+const PLUGIN_NAME = "lingo-compiler";
+function tryLocalOrReturnVirtual(config, fileName, virtualName) {
+	const customPath = path.join(config.sourceRoot, config.lingoDir, fileName);
+	if (fs.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) => generateConfigModule(config),
+		customFileCheck: void 0
+	},
+	"@lingo.dev/compiler/virtual/locale/server": {
+		virtualId: "\0virtual:locale-resolver.server",
+		loader: (config) => generateServerLocaleModule(config),
+		customFileCheck: "locale-resolver.server.ts"
+	},
+	"@lingo.dev/compiler/virtual/locale/client": {
+		virtualId: "\0virtual:locale-resolver.client",
+		loader: (config) => generateClientLocaleModule(config),
+		customFileCheck: "locale-resolver.client.ts"
+	}
+};
+const virtualModulesResolvers = Object.fromEntries(Object.entries(virtualModules).map(([importPath, module]) => [importPath, (config) => module.customFileCheck ? tryLocalOrReturnVirtual(config, module.customFileCheck, module.virtualId) : module.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 = createUnplugin((options) => {
+	const config = createLingoConfig(options);
+	const isDev = config.environment === "development";
+	const startPort = config.dev.translationServerStartPort;
+	let webpackMode;
+	const getMetadataPath$1 = () => {
+		return getMetadataPath(webpackMode ? {
+			...config,
+			environment: webpackMode
+		} : config);
+	};
+	async function startServer() {
+		const server = await startTranslationServer({
+			startPort,
+			onError: (err) => {
+				logger.error("Translation server error:", err);
+			},
+			onReady: (port) => {
+				logger.info(`Translation server started successfully on port: ${port}`);
+			},
+			config
+		});
+		config.dev.translationServerUrl = server.getUrl();
+		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();
+				cleanupExistingMetadata(metadataFilePath);
+				registerCleanupOnCurrentProcess({ cleanup: () => cleanupExistingMetadata(metadataFilePath) });
+				if (isDev && !translationServer) translationServer = await startServer();
+			},
+			async buildEnd() {
+				const metadataFilePath = getMetadataPath$1();
+				if (!isDev) try {
+					await processBuildTranslations({
+						config,
+						publicOutputPath: "public/translations",
+						metadataFilePath
+					});
+				} catch (error) {
+					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, () => {
+				cleanupExistingMetadata(metadataFilePath);
+				registerCleanupOnCurrentProcess({ cleanup: () => 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 processBuildTranslations({
+						config,
+						publicOutputPath: "public/translations",
+						metadataFilePath
+					});
+				} catch (error) {
+					logger.error("Build-time translation processing failed:", error);
+					throw error;
+				}
+			});
+			compiler.hooks.shutdown.tapPromise(PLUGIN_NAME, async () => {
+				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 ? useI18nRegex : void 0
+			},
+			async handler(code, id) {
+				try {
+					const result = transformComponent({
+						code,
+						filePath: id,
+						config
+					});
+					if (!result.transformed) {
+						logger.debug(`No transformation needed for ${id}`);
+						return null;
+					}
+					const metadataManager = new MetadataManager(getMetadataPath$1());
+					if (result.newEntries && result.newEntries.length > 0) {
+						await metadataManager.saveMetadataWithEntries(result.newEntries);
+						logger.debug(`Found ${result.newEntries.length} translatable text(s) in ${id}`);
+					}
+					logger.debug(`Returning transformed code for ${id}`);
+					return {
+						code: result.code,
+						map: result.map
+					};
+				} catch (error) {
+					logger.error(`Transform error in ${id}:`, error);
+					return null;
+				}
+			}
+		}
+	};
+});
+
+//#endregion
+export { lingoUnplugin };
+//# sourceMappingURL=unplugin.mjs.map

package/build/plugin/unplugin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unplugin.mjs","names":["translationServer: TranslationServer","webpackMode: \"development\" | \"production\" | undefined","getMetadataPath","rawGetMetadataPath"],"sources":["../../src/plugin/unplugin.ts"],"sourcesContent":["import { createUnplugin } from \"unplugin\";\nimport { transformComponent } from \"./transform\";\nimport type {\n  LingoConfig,\n  LingoInternalFields,\n  PartialLingoConfig,\n} from \"../types\";\nimport {\n  startTranslationServer,\n  type TranslationServer,\n} from \"../translation-server\";\nimport {\n  cleanupExistingMetadata,\n  getMetadataPath as rawGetMetadataPath,\n  MetadataManager,\n} from \"../metadata/manager\";\nimport { createLingoConfig } from \"../utils/config-factory\";\nimport { logger } from \"../utils/logger\";\nimport { useI18nRegex } from \"./transform/use-i18n\";\nimport {\n  generateClientLocaleModule,\n  generateConfigModule,\n  generateServerLocaleModule,\n} from \"../virtual/code-generator\";\nimport { processBuildTranslations } from \"./build-translator\";\nimport { registerCleanupOnCurrentProcess } from \"./cleanup\";\nimport path from \"path\";\nimport fs from \"fs\";\n\nexport type LingoPluginOptions = PartialLingoConfig;\n\nlet translationServer: TranslationServer;\n\nconst PLUGIN_NAME = \"lingo-compiler\";\n\nfunction tryLocalOrReturnVirtual(\n  config: LingoConfig,\n  fileName: string,\n  virtualName: string,\n) {\n  const customPath = path.join(config.sourceRoot, config.lingoDir, fileName);\n  if (fs.existsSync(customPath)) {\n    return customPath;\n  }\n  return virtualName;\n}\n\n/**\n * Single source of truth for virtual modules\n * Each entry defines both resolver (import path → virtual ID) and loader (virtual ID → code)\n *\n * If customFileCheck is defined, the specified file will be first searched for, and if not found virtual module will be used.\n */\nconst virtualModules = {\n  \"@lingo.dev/compiler/virtual/config\": {\n    virtualId: \"\\0virtual:lingo-config\",\n    loader: (config: LingoConfig) => generateConfigModule(config),\n    customFileCheck: undefined,\n  },\n  \"@lingo.dev/compiler/virtual/locale/server\": {\n    virtualId: \"\\0virtual:locale-resolver.server\" as const,\n    loader: (config: LingoConfig) => generateServerLocaleModule(config),\n    customFileCheck: \"locale-resolver.server.ts\" as const,\n  },\n  \"@lingo.dev/compiler/virtual/locale/client\": {\n    virtualId: \"\\0virtual:locale-resolver.client\" as const,\n    loader: (config: LingoConfig) => generateClientLocaleModule(config),\n    customFileCheck: \"locale-resolver.client.ts\" as const,\n  },\n} as const;\n\n// Derive resolver and loader maps from the single source\nconst virtualModulesResolvers = Object.fromEntries(\n  Object.entries(virtualModules).map(([importPath, module]) => [\n    importPath,\n    (config: LingoConfig) =>\n      module.customFileCheck\n        ? tryLocalOrReturnVirtual(\n            config,\n            module.customFileCheck,\n            module.virtualId,\n          )\n        : module.virtualId,\n  ]),\n);\n\nconst virtualModulesLoaders = Object.fromEntries(\n  Object.values(virtualModules).map((value) => [value.virtualId, value.loader]),\n);\n\n/**\n * Universal plugin for Lingo.dev compiler\n * Supports Vite, Webpack\n */\nexport const lingoUnplugin = createUnplugin<\n  LingoPluginOptions & Partial<Pick<LingoConfig, LingoInternalFields>>\n>((options) => {\n  const config = createLingoConfig(options);\n\n  // Won't work for webpack most likely. Use mode there to set correct environment in configs.\n  const isDev = config.environment === \"development\";\n  const startPort = config.dev.translationServerStartPort;\n\n  // For webpack: store the actual mode and use it to compute the correct metadata path\n  let webpackMode: \"development\" | \"production\" | undefined;\n  // Should be dynamic, because webpack only tells us the mode inside the plugin, not inside the config.\n  const getMetadataPath = () => {\n    return rawGetMetadataPath(\n      webpackMode ? { ...config, environment: webpackMode } : config,\n    );\n  };\n\n  async function startServer() {\n    const server = await startTranslationServer({\n      startPort,\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,\n    });\n    // I don't like this quite a lot. But starting server inside the loader seems lame.\n    config.dev.translationServerUrl = server.getUrl();\n    registerCleanupOnCurrentProcess({\n      asyncCleanup: async () => {\n        await translationServer.stop();\n      },\n    });\n    return server;\n  }\n\n  return {\n    name: PLUGIN_NAME,\n    enforce: \"pre\", // Run before other plugins (especially before React plugin)\n\n    vite: {\n      // Vite handles deep merge\n      config() {\n        // Required for custom virtual like modules to be resolved; otherwise they are bundled with raw source code.\n        return {\n          optimizeDeps: {\n            exclude: [\"@lingo.dev/compiler\"],\n          },\n        };\n      },\n      async buildStart() {\n        const metadataFilePath = getMetadataPath();\n\n        cleanupExistingMetadata(metadataFilePath);\n        registerCleanupOnCurrentProcess({\n          cleanup: () => cleanupExistingMetadata(metadataFilePath),\n        });\n\n        if (isDev && !translationServer) {\n          translationServer = await startServer();\n        }\n      },\n\n      async buildEnd() {\n        const metadataFilePath = getMetadataPath();\n        if (!isDev) {\n          try {\n            await processBuildTranslations({\n              config,\n              publicOutputPath: \"public/translations\",\n              metadataFilePath,\n            });\n          } catch (error) {\n            logger.error(\"Build-time translation processing failed:\", error);\n          }\n        }\n      },\n    },\n\n    webpack(compiler) {\n      webpackMode =\n        compiler.options.mode === \"development\" ? \"development\" : \"production\";\n      const metadataFilePath = getMetadataPath();\n      // Yes, this is dirty play, but webpack runs only for this plugin, and this way we save people from using wrong config\n      config.environment = webpackMode;\n\n      compiler.hooks.initialize.tap(PLUGIN_NAME, () => {\n        cleanupExistingMetadata(metadataFilePath);\n        registerCleanupOnCurrentProcess({\n          cleanup: () => cleanupExistingMetadata(metadataFilePath),\n        });\n      });\n\n      compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, async () => {\n        if (webpackMode === \"development\" && !translationServer) {\n          translationServer = await startServer();\n        }\n      });\n\n      compiler.hooks.additionalPass.tapPromise(PLUGIN_NAME, async () => {\n        if (webpackMode === \"production\") {\n          try {\n            await processBuildTranslations({\n              config,\n              publicOutputPath: \"public/translations\",\n              metadataFilePath,\n            });\n          } catch (error) {\n            logger.error(\"Build-time translation processing failed:\", error);\n            throw error;\n          }\n        }\n      });\n\n      // Duplicates the cleanup process handlers does, but won't hurt since cleanup is idempotent.\n      compiler.hooks.shutdown.tapPromise(PLUGIN_NAME, async () => {\n        cleanupExistingMetadata(metadataFilePath);\n        await translationServer?.stop();\n      });\n    },\n\n    resolveId(id) {\n      const handler = virtualModulesResolvers[id];\n      if (handler) {\n        return handler(config);\n      }\n      return null;\n    },\n\n    load: {\n      filter: {\n        // Without the filter webpack goes mad\n        id: /virtual:/,\n      },\n      handler(id: string) {\n        const handler = virtualModulesLoaders[id];\n        if (handler) {\n          return handler(config);\n        }\n        return null;\n      },\n    },\n\n    transform: {\n      filter: {\n        id: {\n          include: [/\\.[tj]sx$/],\n          exclude: /node_modules/,\n        },\n        // If useDirective is enabled, only process files with \"use i18n\"\n        // This is more efficient than checking in the handler\n        code: config.useDirective ? useI18nRegex : undefined,\n      },\n      async handler(code, id) {\n        try {\n          // Transform the component\n          const result = transformComponent({\n            code,\n            filePath: id,\n            config,\n          });\n\n          // If no transformation occurred, return original code\n          if (!result.transformed) {\n            logger.debug(`No transformation needed for ${id}`);\n            return null;\n          }\n          const metadataManager = new MetadataManager(getMetadataPath());\n\n          // Update metadata with new entries (thread-safe)\n          if (result.newEntries && result.newEntries.length > 0) {\n            await metadataManager.saveMetadataWithEntries(result.newEntries);\n\n            logger.debug(\n              `Found ${result.newEntries.length} translatable text(s) in ${id}`,\n            );\n          }\n\n          logger.debug(`Returning transformed code for ${id}`);\n          return {\n            code: result.code,\n            map: result.map,\n          };\n        } catch (error) {\n          logger.error(`Transform error in ${id}:`, error);\n          return null;\n        }\n      },\n    },\n  };\n});\n"],"mappings":"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"}

package/build/plugin/vite.cjs

@@ -0,0 +1,28 @@
+const require_unplugin = require('./unplugin.cjs');
+
+//#region src/plugin/vite.ts
+/**
+* Vite Plugin for Lingo.dev Compiler
+*
+* Usage:
+* ```ts
+* // vite.config.ts
+* import { defineConfig } from 'vite';
+* import { lingoCompilerPlugin } from '@lingo.dev/compiler/vite';
+*
+* export default defineConfig({
+*   plugins: [
+*     lingoCompilerPlugin({
+*       sourceLocale: 'en',
+*       targetLocales: ['es', 'fr'],
+*     }),
+*   ],
+* });
+* ```
+*/
+function lingoCompilerPlugin(options) {
+	return require_unplugin.lingoUnplugin.vite(options);
+}
+
+//#endregion
+exports.lingoCompilerPlugin = lingoCompilerPlugin;

package/build/plugin/vite.d.cts

@@ -0,0 +1,9 @@
+import { LingoPluginOptions } from "./unplugin.cjs";
+import * as unplugin0 from "unplugin";
+
+//#region src/plugin/vite.d.ts
+
+declare function lingoCompilerPlugin(options: LingoPluginOptions): unplugin0.VitePlugin<any> | unplugin0.VitePlugin<any>[];
+//#endregion
+export { type LingoPluginOptions, lingoCompilerPlugin };
+//# sourceMappingURL=vite.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.cts","names":[],"sources":["../../src/plugin/vite.ts"],"sourcesContent":[],"mappings":";;;;;iBAsBgB,mBAAA,UAA6B,qBAAkB,SAAA,CAAA,kBAAA,SAAA,CAAA"}

package/build/plugin/vite.d.mts

@@ -0,0 +1,9 @@
+import { LingoPluginOptions } from "./unplugin.mjs";
+import * as unplugin0 from "unplugin";
+
+//#region src/plugin/vite.d.ts
+
+declare function lingoCompilerPlugin(options: LingoPluginOptions): unplugin0.VitePlugin<any> | unplugin0.VitePlugin<any>[];
+//#endregion
+export { type LingoPluginOptions, lingoCompilerPlugin };
+//# sourceMappingURL=vite.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.mts","names":[],"sources":["../../src/plugin/vite.ts"],"sourcesContent":[],"mappings":";;;;;iBAsBgB,mBAAA,UAA6B,qBAAkB,SAAA,CAAA,kBAAA,SAAA,CAAA"}

package/build/plugin/vite.mjs

@@ -0,0 +1,29 @@
+import { lingoUnplugin } from "./unplugin.mjs";
+
+//#region src/plugin/vite.ts
+/**
+* Vite Plugin for Lingo.dev Compiler
+*
+* Usage:
+* ```ts
+* // vite.config.ts
+* import { defineConfig } from 'vite';
+* import { lingoCompilerPlugin } from '@lingo.dev/compiler/vite';
+*
+* export default defineConfig({
+*   plugins: [
+*     lingoCompilerPlugin({
+*       sourceLocale: 'en',
+*       targetLocales: ['es', 'fr'],
+*     }),
+*   ],
+* });
+* ```
+*/
+function lingoCompilerPlugin(options) {
+	return lingoUnplugin.vite(options);
+}
+
+//#endregion
+export { lingoCompilerPlugin };
+//# sourceMappingURL=vite.mjs.map

package/build/plugin/vite.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.mjs","names":[],"sources":["../../src/plugin/vite.ts"],"sourcesContent":["/**\n * Vite Plugin for Lingo.dev Compiler\n *\n * Usage:\n * ```ts\n * // vite.config.ts\n * import { defineConfig } from 'vite';\n * import { lingoCompilerPlugin } from '@lingo.dev/compiler/vite';\n *\n * export default defineConfig({\n *   plugins: [\n *     lingoCompilerPlugin({\n *       sourceLocale: 'en',\n *       targetLocales: ['es', 'fr'],\n *     }),\n *   ],\n * });\n * ```\n */\n\nimport { type LingoPluginOptions, lingoUnplugin } from \"./unplugin\";\n\nexport function lingoCompilerPlugin(options: LingoPluginOptions) {\n  return lingoUnplugin.vite(options);\n}\n\nexport type { LingoPluginOptions };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,oBAAoB,SAA6B;AAC/D,QAAO,cAAc,KAAK,QAAQ"}

package/build/plugin/webpack.cjs

@@ -0,0 +1,27 @@
+const require_unplugin = require('./unplugin.cjs');
+
+//#region src/plugin/webpack.ts
+/**
+* Webpack Plugin for Lingo.dev Compiler
+*
+* Usage:
+* ```js
+* // webpack.config.js
+* import { lingoCompilerPlugin } from '@lingo.dev/compiler/webpack';
+*
+* export default {
+*   plugins: [
+*     lingoCompilerPlugin({
+*       sourceLocale: 'en',
+*       targetLocales: ['es', 'fr'],
+*     }),
+*   ],
+* };
+* ```
+*/
+function lingoCompilerPlugin(options) {
+	return require_unplugin.lingoUnplugin.webpack(options);
+}
+
+//#endregion
+exports.lingoCompilerPlugin = lingoCompilerPlugin;

package/build/plugin/webpack.d.cts

@@ -0,0 +1,8 @@
+import { LingoPluginOptions } from "./unplugin.cjs";
+
+//#region src/plugin/webpack.d.ts
+
+declare function lingoCompilerPlugin(options: LingoPluginOptions): WebpackPluginInstance;
+//#endregion
+export { type LingoPluginOptions, lingoCompilerPlugin };
+//# sourceMappingURL=webpack.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webpack.d.cts","names":[],"sources":["../../src/plugin/webpack.ts"],"sourcesContent":[],"mappings":";;;;iBAqBgB,mBAAA,UAA6B,qBAAkB"}

package/build/plugin/webpack.d.mts

@@ -0,0 +1,8 @@
+import { LingoPluginOptions } from "./unplugin.mjs";
+
+//#region src/plugin/webpack.d.ts
+
+declare function lingoCompilerPlugin(options: LingoPluginOptions): WebpackPluginInstance;
+//#endregion
+export { type LingoPluginOptions, lingoCompilerPlugin };
+//# sourceMappingURL=webpack.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webpack.d.mts","names":[],"sources":["../../src/plugin/webpack.ts"],"sourcesContent":[],"mappings":";;;;iBAqBgB,mBAAA,UAA6B,qBAAkB"}

package/build/plugin/webpack.mjs

@@ -0,0 +1,28 @@
+import { lingoUnplugin } from "./unplugin.mjs";
+
+//#region src/plugin/webpack.ts
+/**
+* Webpack Plugin for Lingo.dev Compiler
+*
+* Usage:
+* ```js
+* // webpack.config.js
+* import { lingoCompilerPlugin } from '@lingo.dev/compiler/webpack';
+*
+* export default {
+*   plugins: [
+*     lingoCompilerPlugin({
+*       sourceLocale: 'en',
+*       targetLocales: ['es', 'fr'],
+*     }),
+*   ],
+* };
+* ```
+*/
+function lingoCompilerPlugin(options) {
+	return lingoUnplugin.webpack(options);
+}
+
+//#endregion
+export { lingoCompilerPlugin };
+//# sourceMappingURL=webpack.mjs.map

package/build/plugin/webpack.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack.mjs","names":[],"sources":["../../src/plugin/webpack.ts"],"sourcesContent":["/**\n * Webpack Plugin for Lingo.dev Compiler\n *\n * Usage:\n * ```js\n * // webpack.config.js\n * import { lingoCompilerPlugin } from '@lingo.dev/compiler/webpack';\n *\n * export default {\n *   plugins: [\n *     lingoCompilerPlugin({\n *       sourceLocale: 'en',\n *       targetLocales: ['es', 'fr'],\n *     }),\n *   ],\n * };\n * ```\n */\n\nimport { lingoUnplugin, type LingoPluginOptions } from \"./unplugin\";\n\nexport function lingoCompilerPlugin(options: LingoPluginOptions) {\n  return lingoUnplugin.webpack(options);\n}\n\nexport type { LingoPluginOptions };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,oBAAoB,SAA6B;AAC/D,QAAO,cAAc,QAAQ,QAAQ"}

package/build/react/client/index.cjs

@@ -0,0 +1,9 @@
+const require_LingoContext = require('../shared/LingoContext.cjs');
+const require_LingoProvider = require('../shared/LingoProvider.cjs');
+const require_LocaleSwitcher = require('../shared/LocaleSwitcher.cjs');
+const require_useTranslation = require('./useTranslation.cjs');
+
+exports.LingoProvider = require_LingoProvider.LingoProvider;
+exports.LocaleSwitcher = require_LocaleSwitcher.LocaleSwitcher;
+exports.useLingoContext = require_LingoContext.useLingoContext;
+exports.useTranslation = require_useTranslation.useTranslation;

package/build/react/client/index.d.cts

@@ -0,0 +1,5 @@
+import { LingoProvider, LingoProviderProps } from "../shared/LingoProvider.cjs";
+import { useLingoContext } from "../shared/LingoContext.cjs";
+import { useTranslation } from "./useTranslation.cjs";
+import { LocaleSwitcher } from "../shared/LocaleSwitcher.cjs";
+export { LingoProvider, type LingoProviderProps, LocaleSwitcher, useLingoContext, useTranslation };

package/build/react/client/index.d.mts

@@ -0,0 +1,5 @@
+import { LingoProvider, LingoProviderProps } from "../shared/LingoProvider.mjs";
+import { useLingoContext } from "../shared/LingoContext.mjs";
+import { useTranslation } from "./useTranslation.mjs";
+import { LocaleSwitcher } from "../shared/LocaleSwitcher.mjs";
+export { LingoProvider, type LingoProviderProps, LocaleSwitcher, useLingoContext, useTranslation };

package/build/react/client/index.mjs

@@ -0,0 +1,6 @@
+import { useLingoContext } from "../shared/LingoContext.mjs";
+import { LingoProvider } from "../shared/LingoProvider.mjs";
+import { LocaleSwitcher } from "../shared/LocaleSwitcher.mjs";
+import { useTranslation } from "./useTranslation.mjs";
+
+export { LingoProvider, LocaleSwitcher, useLingoContext, useTranslation };

package/build/react/client/useTranslation.cjs

@@ -0,0 +1,71 @@
+"use client";
+
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_logger = require('../../utils/logger.cjs');
+const require_LingoContext = require('../shared/LingoContext.cjs');
+const require_render_rich_text = require('../shared/render-rich-text.cjs');
+let react = require("react");
+
+//#region src/react/client/useTranslation.ts
+/**
+* useTranslation Hook
+*
+* Returns a translation function `t(hash, source, params?)` that:
+* - Returns original text for source locale
+* - Returns translated text for target locales
+* - Supports rich text with variable and component placeholders
+* - Automatically requests missing translations
+* - Falls back to source text while loading
+*
+* This hook is automatically injected by the Babel plugin.
+* You typically don't need to call it manually.
+*
+* @param hashes - Static list of all translation hashes used in this component (injected at build time)
+*
+* @example
+* ```tsx
+* 'use client';
+*
+* export function Welcome() {
+*   const t = useTranslation(['hash_abc123', 'hash_def456']);
+*
+*   return (
+*     <div>
+*       <h1>{t('hash_abc123', 'Welcome')}</h1>
+*       <p>{t('hash_def456', 'Hello {name}', { name: 'Alice' })}</p>
+*       <p>{t('hash_def789', 'Click <a0>here</a0>', {
+*         a0: (chunks) => <a href="/home">{chunks}</a>
+*       })}</p>
+*     </div>
+*   );
+* }
+* ```
+*/
+const useTranslation = (hashes) => {
+	const { translations, registerHashes, locale, sourceLocale } = require_LingoContext.useLingoContext();
+	(0, react.useEffect)(() => {
+		require_logger.logger.debug(`Registering ${hashes.length} hashes for component`);
+		registerHashes(hashes);
+	}, [
+		hashes,
+		registerHashes,
+		locale,
+		sourceLocale
+	]);
+	return {
+		t: (0, react.useCallback)((hash, source, params) => {
+			require_logger.logger.debug(`Client. The translations for locale ${locale} are: ${JSON.stringify(translations)}`);
+			const text = translations[hash] || source;
+			if (!params) return text;
+			return require_render_rich_text.renderRichText(text, params, locale);
+		}, [
+			translations,
+			locale,
+			sourceLocale
+		]),
+		locale
+	};
+};
+
+//#endregion
+exports.useTranslation = useTranslation;

package/build/react/client/useTranslation.d.cts

@@ -0,0 +1,42 @@
+import { TranslationHook } from "../types.cjs";
+
+//#region src/react/client/useTranslation.d.ts
+
+/**
+ * useTranslation Hook
+ *
+ * Returns a translation function `t(hash, source, params?)` that:
+ * - Returns original text for source locale
+ * - Returns translated text for target locales
+ * - Supports rich text with variable and component placeholders
+ * - Automatically requests missing translations
+ * - Falls back to source text while loading
+ *
+ * This hook is automatically injected by the Babel plugin.
+ * You typically don't need to call it manually.
+ *
+ * @param hashes - Static list of all translation hashes used in this component (injected at build time)
+ *
+ * @example
+ * ```tsx
+ * 'use client';
+ *
+ * export function Welcome() {
+ *   const t = useTranslation(['hash_abc123', 'hash_def456']);
+ *
+ *   return (
+ *     <div>
+ *       <h1>{t('hash_abc123', 'Welcome')}</h1>
+ *       <p>{t('hash_def456', 'Hello {name}', { name: 'Alice' })}</p>
+ *       <p>{t('hash_def789', 'Click <a0>here</a0>', {
+ *         a0: (chunks) => <a href="/home">{chunks}</a>
+ *       })}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare const useTranslation: TranslationHook;
+//#endregion
+export { useTranslation };
+//# sourceMappingURL=useTranslation.d.cts.map

package/build/react/client/useTranslation.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslation.d.cts","names":[],"sources":["../../../src/react/client/useTranslation.ts"],"sourcesContent":[],"mappings":";;;;;;AA6CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,gBAAgB"}

package/build/react/client/useTranslation.d.mts

@@ -0,0 +1,42 @@
+import { TranslationHook } from "../types.mjs";
+
+//#region src/react/client/useTranslation.d.ts
+
+/**
+ * useTranslation Hook
+ *
+ * Returns a translation function `t(hash, source, params?)` that:
+ * - Returns original text for source locale
+ * - Returns translated text for target locales
+ * - Supports rich text with variable and component placeholders
+ * - Automatically requests missing translations
+ * - Falls back to source text while loading
+ *
+ * This hook is automatically injected by the Babel plugin.
+ * You typically don't need to call it manually.
+ *
+ * @param hashes - Static list of all translation hashes used in this component (injected at build time)
+ *
+ * @example
+ * ```tsx
+ * 'use client';
+ *
+ * export function Welcome() {
+ *   const t = useTranslation(['hash_abc123', 'hash_def456']);
+ *
+ *   return (
+ *     <div>
+ *       <h1>{t('hash_abc123', 'Welcome')}</h1>
+ *       <p>{t('hash_def456', 'Hello {name}', { name: 'Alice' })}</p>
+ *       <p>{t('hash_def789', 'Click <a0>here</a0>', {
+ *         a0: (chunks) => <a href="/home">{chunks}</a>
+ *       })}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare const useTranslation: TranslationHook;
+//#endregion
+export { useTranslation };
+//# sourceMappingURL=useTranslation.d.mts.map

package/build/react/client/useTranslation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslation.d.mts","names":[],"sources":["../../../src/react/client/useTranslation.ts"],"sourcesContent":[],"mappings":";;;;;;AA6CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,gBAAgB"}

package/build/react/client/useTranslation.mjs

@@ -0,0 +1,71 @@
+"use client";
+
+import { logger } from "../../utils/logger.mjs";
+import { useLingoContext } from "../shared/LingoContext.mjs";
+import { renderRichText } from "../shared/render-rich-text.mjs";
+import { useCallback, useEffect } from "react";
+
+//#region src/react/client/useTranslation.ts
+/**
+* useTranslation Hook
+*
+* Returns a translation function `t(hash, source, params?)` that:
+* - Returns original text for source locale
+* - Returns translated text for target locales
+* - Supports rich text with variable and component placeholders
+* - Automatically requests missing translations
+* - Falls back to source text while loading
+*
+* This hook is automatically injected by the Babel plugin.
+* You typically don't need to call it manually.
+*
+* @param hashes - Static list of all translation hashes used in this component (injected at build time)
+*
+* @example
+* ```tsx
+* 'use client';
+*
+* export function Welcome() {
+*   const t = useTranslation(['hash_abc123', 'hash_def456']);
+*
+*   return (
+*     <div>
+*       <h1>{t('hash_abc123', 'Welcome')}</h1>
+*       <p>{t('hash_def456', 'Hello {name}', { name: 'Alice' })}</p>
+*       <p>{t('hash_def789', 'Click <a0>here</a0>', {
+*         a0: (chunks) => <a href="/home">{chunks}</a>
+*       })}</p>
+*     </div>
+*   );
+* }
+* ```
+*/
+const useTranslation = (hashes) => {
+	const { translations, registerHashes, locale, sourceLocale } = useLingoContext();
+	useEffect(() => {
+		logger.debug(`Registering ${hashes.length} hashes for component`);
+		registerHashes(hashes);
+	}, [
+		hashes,
+		registerHashes,
+		locale,
+		sourceLocale
+	]);
+	return {
+		t: useCallback((hash, source, params) => {
+			logger.debug(`Client. The translations for locale ${locale} are: ${JSON.stringify(translations)}`);
+			const text = translations[hash] || source;
+			if (!params) return text;
+			return renderRichText(text, params, locale);
+		}, [
+			translations,
+			locale,
+			sourceLocale
+		]),
+		locale
+	};
+};
+
+//#endregion
+export { useTranslation };
+//# sourceMappingURL=useTranslation.mjs.map