Translation Loaders

import { createApiTranslationLoader } from '@hua-labs/i18n-loaders';
import { createCoreI18n } from '@hua-labs/i18n-core';

// Production-ready loader with caching, retry, and dev auto-invalidation
// Returns TranslationLoader function with .invalidate() and .clear() methods
const loader = createApiTranslationLoader({
  translationApiPath: '/api/translations',
  baseUrl: process.env.NEXT_PUBLIC_BASE_URL,
  retryCount: 2,
  retryDelay: 1000,
  cacheTtlMs: 5 * 60 * 1000, // 5 minutes
  autoInvalidateInDev: true,
});

// Pass to createCoreI18n
const I18nProvider = createCoreI18n({
  defaultLanguage: 'ko',
  supportedLanguages: [
    { code: 'ko', name: 'Korean', nativeName: '한국어' },
    { code: 'en', name: 'English', nativeName: 'English' },
  ],
  namespaces: ['common', 'navigation'],
  translationLoader: 'custom',
  loadTranslations: loader,
});

// Cache management via attached methods
loader.invalidate('ko', 'common'); // Invalidate specific
loader.invalidate('ko');            // Invalidate all for language
loader.clear();                     // Clear all cache

import { preloadNamespaces, warmFallbackLanguages } from '@hua-labs/i18n-loaders';

// Preload critical namespaces at app startup
// preloadNamespaces(language, namespaces, loader, options?)
await preloadNamespaces('ko', ['common', 'navigation'], loader, { suppressErrors: true });
await preloadNamespaces('en', ['common', 'navigation'], loader);

// Warm fallback language cache for instant switching
// warmFallbackLanguages(currentLanguage, languages, namespaces, loader, options?)
await warmFallbackLanguages('ko', ['ko', 'en', 'ja'], ['common'], loader);

/**
 * Translation Loader Comparison
 * 번역 로더 비교
 *
 * | Loader   | Location            | SSR Support | Use Case                    |
 * |----------|---------------------|-------------|-----------------------------|
 * | api      | lib/translations/   | ✅ Yes      | Production apps, SSR        |
 * | static   | public/translations/| ❌ No       | Simple apps, prototypes     |
 * | custom   | Any                 | ✅ Possible | CMS, external APIs          |
 */

// hua.config.ts - API Loader (Recommended for SSR)
import { defineConfig } from '@hua-labs/hua/framework';

export default defineConfig({
  i18n: {
    defaultLanguage: 'ko',
    supportedLanguages: ['ko', 'en', 'ja'],
    namespaces: ['common', 'navigation'],
    translationLoader: 'api',  // Load from lib/translations/
    translationApiPath: '/api/translations',
  },
});

// File structure:
// your-app/
// ├── lib/
// │   └── translations/
// │       ├── ko/
// │       │   ├── common.json
// │       │   └── navigation.json
// │       └── en/
// │           ├── common.json
// │           └── navigation.json

// hua.config.ts - Static Loader (No SSR)
import { defineConfig } from '@hua-labs/hua/framework';

export default defineConfig({
  i18n: {
    defaultLanguage: 'ko',
    supportedLanguages: ['ko', 'en'],
    namespaces: ['common'],
    translationLoader: 'static',  // Load from public/translations/
  },
});

// File structure:
// your-app/
// └── public/
//     └── translations/
//         ├── ko/
//         │   └── common.json
//         └── en/
//             └── common.json

// ⚠️ Warning: Static loader causes language flickering on SSR
// because translations are fetched client-side after hydration.

// hua.config.ts - Custom Loader
import { defineConfig } from '@hua-labs/hua/framework';

export default defineConfig({
  i18n: {
    defaultLanguage: 'ko',
    supportedLanguages: ['ko', 'en'],
    namespaces: ['common'],
    translationLoader: 'custom',
    customLoader: async (language: string, namespace: string) => {
      // Load from CMS, external API, or any source
      const response = await fetch(
        `https://cms.example.com/translations/${language}/${namespace}`
      );
      return response.json();
    },
  },
});

// app/api/translations/[language]/[namespace]/route.ts
import { NextResponse } from "next/server";
import fs from "fs";
import path from "path";

export async function GET(
  request: Request,
  { params }: { params: Promise<{ language: string; namespace: string }> }
) {
  const { language, namespace } = await params;

  // API loader reads from lib/translations/ (not public/)
  const filePath = path.join(
    process.cwd(),
    "lib/translations",  // ← Server-side only, supports SSR
    language,
    `${namespace}.json`
  );

  try {
    const content = fs.readFileSync(filePath, "utf-8");
    return NextResponse.json(JSON.parse(content));
  } catch {
    return NextResponse.json({}, { status: 404 });
  }
}