feat: sort out loggers

Author: AleksandrSl

cmp/compiler/src/plugin/next.ts

@@ -1,15 +1,8 @@
 import type { NextConfig } from "next";
 
-import path from "path";
-import fs from "fs/promises";
-import {
-  getCacheDir,
-  getCachePath,
-  getConfigPath,
-} from "../utils/path-helpers";
+import { getConfigPath } from "../utils/path-helpers";
 import { createLingoConfig } from "../utils/config-factory";
-import { logger } from "../utils/logger";
-import { startTranslationServer } from "../translation-server";
+import { logger, loggerRegistry } from "../utils/logger";
 import type { PartialLingoConfig } from "../types";
 import type { TurbopackOptions } from "next/dist/server/config-shared";
 
@@ -71,6 +64,12 @@ function buildLingoConfig(
 ): NextConfig {
   const lingoConfig = createLingoConfig(lingoOptions);
 
+  loggerRegistry.create("plugin", {
+    enableConsole: true,
+    // TODO (AleksandrSl 04/12/2025): Make configurable
+    enableDebug: true,
+  });
+
   // Prepare Turbopack loader configuration
   const loaderConfig = {
     loader: "@lingo.dev/_compiler/turbopack-loader",
@@ -156,63 +155,17 @@ function buildLingoConfig(
     }
 
     logger.info("Running post-build translation generation...");
-    let translationServer:
-      | Awaited<ReturnType<typeof startTranslationServer>>
-      | undefined;
-    try {
-      translationServer = await startTranslationServer({
-        startPort: lingoConfig.dev?.serverStartPort,
-        onError: (err) => {
-          logger.error("Translation server error:", err);
-        },
-        config: lingoConfig,
-      });
-
-      logger.info(
-        `Processing translations for ${lingoConfig.targetLocales.length} locale(s)...`,
-      );
 
-      // Translate all locales in parallel
-      // Each translator handles its own batching strategy internally
-      const localePromises = lingoConfig.targetLocales.map(async (locale) => {
-        logger.info(`Translating to ${locale}...`);
-
-        const result = await translationServer!.translateAll(locale);
+    try {
+      const { processBuildTranslations } = await import("./build-translator");
 
-        if (result.errors.length > 0) {
-          logger.warn(
-            `Translation completed with ${result.errors.length} errors for ${locale}`,
-          );
-        }
-        logger.info(`${locale} completed`);
+      await processBuildTranslations({
+        config: lingoConfig,
+        publicOutputPath: distDir,
       });
-
-      await Promise.all(localePromises);
-
-      const publicPath = distDir;
-      logger.info(`Generating static translation files in ${distDir}`);
-
-      await fs.mkdir(publicPath, { recursive: true });
-
-      for (const locale of lingoOptions.targetLocales) {
-        const cacheFilePath = getCachePath(lingoConfig, locale);
-        const publicFilePath = path.join(publicPath, `${locale}.json`);
-
-        try {
-          await fs.copyFile(cacheFilePath, publicFilePath);
-          logger.info(`✓ Generated ${locale}.json`);
-        } catch (error) {
-          logger.error(`Failed to copy ${locale}.json:`, error);
-        }
-      }
-
-      logger.info("Translation generation completed successfully");
     } catch (error) {
       logger.error("Translation generation failed:", error);
       throw error;
-    } finally {
-      translationServer?.stop();
-      logger.info("Shutting down translation server...");
     }
   };
 

cmp/compiler/src/plugin/unplugin.ts

@@ -131,6 +131,25 @@ export const cacheDir = ${JSON.stringify(cacheDir)};`;
     },
 
     async buildEnd() {
+      // Process build-time translations (only in production)
+      if (!isDev) {
+        try {
+          const { processBuildTranslations } = await import(
+            "./build-translator"
+          );
+
+          await processBuildTranslations({
+            config,
+            // Note: publicOutputPath can be set by users in their config
+            // For Vite, this might be dist/public or public/translations
+            // For now, we don't set it here - users can handle it in their pipeline
+          });
+        } catch (error) {
+          logger.error("Build-time translation processing failed:", error);
+          throw error;
+        }
+      }
+
       // Stop translation server
       if (globalServer) {
         await globalServer.stop();