@raclettejs/core 0.1.2 → 0.1.4

package/services/frontend/src/orchestrator/setup/i18n.ts

@@ -6,12 +6,12 @@ import defaultNumberFormats from "../i18n/numberFormats"
 import configService from "@racletteCore/lib/configService"
 import logger from "@racletteCore/lib/logger"
 import { mergeDeepRight } from "ramda"
+import { $store } from "@racletteCore"
 
 // Types
 type LocaleFileImports = Record<string, () => Promise<any>>
 type Messages = Record<string, any>
 type DateLocales = Record<string, any>
-type LocaleEnrichmentMap = Record<string, string[]>
 type SectionPriorities = Record<string, number>
 
 interface I18nInstance {
@@ -48,359 +48,502 @@ let instanceAdapter: { adapter: any } | null = null
 let dateLocale: DateLocales = {}
 let messages: Messages = {}
 
-// Utility functions
-const extractLocaleFromFilePath = (filePath: string): string => {
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
+
+const extractLocaleFromPath = (filePath: string): string => {
   const fileName = filePath.split("/").pop()!
   return fileName.replace(/\.(json|js)$/, "")
 }
 
-const getShortLocale = (longLocale: string): string => {
-  return longLocale.split("-")[0]
+const getLanguageCode = (locale: string): string => {
+  return locale.split("-")[0]
 }
 
 const getAvailableLocales = (files: LocaleFileImports): string[] => {
-  return Object.keys(files).map(extractLocaleFromFilePath)
+  return Object.keys(files).map(extractLocaleFromPath)
 }
 
-const getAvailableDateFnsLocales = (files: LocaleFileImports): string[] => {
-  return Object.keys(files)
-    .map(extractLocaleFromFilePath)
-    .filter((locale) => !locale.includes("cdn") && locale !== "types")
+const filterValidDateFnsLocales = (locales: string[]): string[] => {
+  return locales.filter(
+    (locale) => !locale.includes("cdn") && locale !== "types",
+  )
 }
 
-const createFormatsForLocales = (
+const createFormatsForAllLocales = (
   locales: string[],
-  defaultFormats: any
+  defaultFormats: any,
 ): Record<string, any> => {
-  return locales.reduce((formats, locale) => {
-    formats[locale] = defaultFormats.EU
-    return formats
-  }, {} as Record<string, any>)
+  return locales.reduce(
+    (formats, locale) => {
+      formats[locale] = defaultFormats.EU
+      return formats
+    },
+    {} as Record<string, any>,
+  )
 }
 
-// Locale filtering functions
-const createLocaleFilter = (targetLocales: string[]) => {
-  return (files: LocaleFileImports): LocaleFileImports => {
-    const filtered: LocaleFileImports = {}
-    
-    Object.entries(files).forEach(([filePath, importFn]) => {
-      const fileLocale = extractLocaleFromFilePath(filePath)
-      if (targetLocales.includes(fileLocale)) {
-        filtered[filePath] = importFn
-      }
-    })
-    
-    return filtered
+// ============================================================================
+// LOCALE ENRICHMENT (FALLBACK CHAIN)
+// ============================================================================
+
+class LocaleEnrichment {
+  private requestedLocales: string[]
+  private availableLocales: string[]
+  private fallbackLocale: string
+
+  constructor(
+    requestedLocales: string[],
+    availableLocales: string[],
+    fallbackLocale: string,
+  ) {
+    this.requestedLocales = requestedLocales
+    this.availableLocales = availableLocales
+    this.fallbackLocale = fallbackLocale
   }
-}
 
-const createDateFnsLocaleFilter = (requestedLocales: string[]) => {
-  return (files: LocaleFileImports): LocaleFileImports => {
-    const filtered: LocaleFileImports = {}
-    const availableDateFnsLocales = getAvailableDateFnsLocales(files)
-
-    requestedLocales.forEach((locale) => {
-      const targetLocale = findBestDateFnsLocale(locale, availableDateFnsLocales)
-      
-      if (targetLocale) {
-        const matchingFilePath = Object.keys(files).find((filePath) => {
-          return extractLocaleFromFilePath(filePath) === targetLocale
-        })
-
-        if (matchingFilePath) {
-          filtered[matchingFilePath] = files[matchingFilePath]
-        }
+  private buildFallbackChain(targetLocale: string): string[] {
+    const chain: string[] = []
+    const languageCode = getLanguageCode(targetLocale)
+
+    // 1. Try exact match
+    if (this.availableLocales.includes(targetLocale)) {
+      chain.push(targetLocale)
+    }
+
+    // 2. Try same language, different region
+    const sameLanguageLocales = this.availableLocales.filter(
+      (locale) =>
+        locale !== targetLocale &&
+        getLanguageCode(locale) === languageCode &&
+        locale.includes("-"),
+    )
+    chain.push(...sameLanguageLocales)
+
+    // 3. Try language code only
+    if (
+      this.availableLocales.includes(languageCode) &&
+      !chain.includes(languageCode)
+    ) {
+      chain.push(languageCode)
+    }
+
+    return chain
+  }
+
+  createEnrichmentMap(): Record<string, string[]> {
+    const enrichmentMap: Record<string, string[]> = {}
+
+    for (const locale of this.requestedLocales) {
+      let fallbackChain = this.buildFallbackChain(locale)
+
+      // Add fallback locale if nothing found
+      if (
+        fallbackChain.length === 0 &&
+        this.availableLocales.includes(this.fallbackLocale)
+      ) {
+        fallbackChain = [this.fallbackLocale]
       }
-    })
-    
-    return filtered
+
+      if (fallbackChain.length > 0) {
+        enrichmentMap[locale] = fallbackChain
+        logger.orchestrator(`Fallback chain for ${locale}:`, fallbackChain)
+      }
+    }
+
+    return enrichmentMap
   }
 }
 
-const findBestDateFnsLocale = (
-  requestedLocale: string,
-  availableLocales: string[]
-): string | null => {
-  // Try exact match first
-  if (availableLocales.includes(requestedLocale)) {
-    return requestedLocale
-  }
-  
-  // Try short locale
-  const shortLocale = getShortLocale(requestedLocale)
-  if (availableLocales.includes(shortLocale)) {
-    return shortLocale
-  }
-  
-  // Fallback to "eu"
-  if (availableLocales.includes("eu")) {
-    return "eu"
+// ============================================================================
+// MESSAGE LOADING AND PROCESSING
+// ============================================================================
+
+class MessageProcessor {
+  private priorities: SectionPriorities
+
+  constructor(priorities: SectionPriorities) {
+    this.priorities = priorities
   }
-  
-  return null
-}
 
-// Locale enrichment logic
-const buildFallbackChain = (
-  requestedLocale: string,
-  availableLocales: string[]
-): string[] => {
-  const fallbackChain: string[] = []
-  const requestedLang = getShortLocale(requestedLocale)
-
-  // 1. Exact match
-  if (availableLocales.includes(requestedLocale)) {
-    fallbackChain.push(requestedLocale)
+  private extractSectionFromPath(filePath: string): string {
+    const pathParts = filePath.split("/")
+    const i18nIndex = pathParts.findIndex((part) => part === "i18n")
+    const folderPath = pathParts.slice(i18nIndex + 1, -1).join("/")
+    return folderPath || "."
   }
 
-  // 2. Same language, different region
-  const sameLanguageDifferentRegion = availableLocales.filter(
-    (locale) =>
-      locale !== requestedLocale &&
-      getShortLocale(locale) === requestedLang &&
-      locale.includes("-")
-  )
-  fallbackChain.push(...sameLanguageDifferentRegion)
+  private async loadI18nFiles(
+    files: LocaleFileImports,
+  ): Promise<Record<string, LocaleSection[]>> {
+    const sectionsByLocale: Record<string, LocaleSection[]> = {}
+
+    for (const [filePath, importFn] of Object.entries(files)) {
+      try {
+        const module = await importFn()
+        const content = module.default || module
+        const locale = extractLocaleFromPath(filePath)
+        const section = this.extractSectionFromPath(filePath)
+        const priority = this.priorities[section]
+
+        if (priority === undefined) {
+          logger.warning(
+            `Section "${section}" for locale "${locale}" has no priority - skipping`,
+          )
+          continue
+        }
+
+        if (!sectionsByLocale[locale]) {
+          sectionsByLocale[locale] = []
+        }
 
-  // 3. Short locale
-  if (availableLocales.includes(requestedLang) && !fallbackChain.includes(requestedLang)) {
-    fallbackChain.push(requestedLang)
+        sectionsByLocale[locale].push({ section, content, priority })
+      } catch (error) {
+        logger.error(`Failed to load i18n file ${filePath}:`, error)
+      }
+    }
+
+    return sectionsByLocale
   }
 
-  return fallbackChain
-}
+  private mergeSectionsByPriority(
+    sectionsByLocale: Record<string, LocaleSection[]>,
+  ): Record<string, any> {
+    const mergedByLocale: Record<string, any> = {}
 
-const createLocaleEnrichmentMap = (
-  requestedLocales: string[],
-  availableLocales: string[],
-  fallbackLocale: string
-): LocaleEnrichmentMap => {
-  const enrichmentMap: LocaleEnrichmentMap = {}
-
-  requestedLocales.forEach((requestedLocale) => {
-    let fallbackChain = buildFallbackChain(requestedLocale, availableLocales)
-    
-    // Add fallback locale if nothing else was found
-    if (fallbackChain.length === 0 && availableLocales.includes(fallbackLocale)) {
-      fallbackChain = [fallbackLocale]
+    for (const [locale, sections] of Object.entries(sectionsByLocale)) {
+      // Sort by priority (highest number = lowest priority, so merge first)
+      const sortedSections = sections.sort((a, b) => b.priority - a.priority)
+
+      // Merge from lowest to highest priority
+      mergedByLocale[locale] = sortedSections.reduce((merged, { content }) => {
+        return mergeDeepRight(merged, content || {})
+      }, {})
     }
 
-    if (fallbackChain.length > 0) {
-      enrichmentMap[requestedLocale] = fallbackChain
-      logger.orchestrator(`Enrichment chain for ${requestedLocale}:`, fallbackChain)
+    return mergedByLocale
+  }
+
+  private enrichWithFallbacks(
+    enrichmentMap: Record<string, string[]>,
+    mergedByLocale: Record<string, any>,
+  ): Messages {
+    const enrichedMessages: Messages = {}
+
+    for (const [requestedLocale, fallbackChain] of Object.entries(
+      enrichmentMap,
+    )) {
+      let localeMessages = {}
+
+      // Merge in reverse order (lowest priority first)
+      const reversedChain = [...fallbackChain].reverse()
+      for (const sourceLocale of reversedChain) {
+        if (mergedByLocale[sourceLocale]) {
+          localeMessages = mergeDeepRight(
+            localeMessages,
+            mergedByLocale[sourceLocale],
+          )
+          logger.orchestrator(`Merged ${sourceLocale} into ${requestedLocale}`)
+        }
+      }
+
+      enrichedMessages[requestedLocale] = localeMessages
     }
-  })
 
-  return enrichmentMap
+    return enrichedMessages
+  }
+
+  async processMessages(
+    files: LocaleFileImports,
+    enrichmentMap: Record<string, string[]>,
+  ): Promise<Messages> {
+    const sectionsByLocale = await this.loadI18nFiles(files)
+    const mergedByLocale = this.mergeSectionsByPriority(sectionsByLocale)
+    return this.enrichWithFallbacks(enrichmentMap, mergedByLocale)
+  }
 }
 
-// Message loading functions
-const extractSectionFromFilePath = (filePath: string): string => {
-  const pathParts = filePath.split("/")
-  const i18nIndex = pathParts.findIndex((part) => part === "i18n")
-  const folderPath = pathParts.slice(i18nIndex + 1, -1).join("/")
-  return folderPath || "."
+// ============================================================================
+// VUETIFY LOCALE LOADER
+// ============================================================================
+
+class VuetifyLocaleLoader {
+  async loadVuetifyLocales(
+    files: LocaleFileImports,
+    requestedLocales: string[],
+    messages: Messages,
+  ): Promise<void> {
+    for (const [filePath, importFn] of Object.entries(files)) {
+      try {
+        const module = await importFn()
+        const vuetifyLocale = module.default || module
+        const shortLocale = extractLocaleFromPath(filePath)
+
+        // Find matching long locales
+        const matchingLocales = requestedLocales.filter(
+          (locale) => getLanguageCode(locale) === shortLocale,
+        )
+
+        for (const locale of matchingLocales) {
+          if (messages[locale]) {
+            messages[locale].$vuetify = vuetifyLocale
+          }
+        }
+      } catch (error) {
+        logger.error(`Failed to load Vuetify locale ${filePath}:`, error)
+      }
+    }
+  }
 }
 
-const loadAndCategorizeI18nFiles = async (
-  files: LocaleFileImports,
-  priorities: SectionPriorities
-): Promise<Record<string, LocaleSection[]>> => {
-  const sectionsByLocale: Record<string, LocaleSection[]> = {}
-
-  for (const [filePath, importFn] of Object.entries(files)) {
-    const module = await importFn()
-    const content = module.default || module
-    const fileLocale = extractLocaleFromFilePath(filePath)
-    const section = extractSectionFromFilePath(filePath)
-    const priority = priorities[section]
-
-    if (priority === undefined) {
-      logger.warning(
-        `Section "${section}" for locale "${fileLocale}" has no priority defined and will be skipped`
-      )
-      continue
+// ============================================================================
+// DATE-FNS LOCALE LOADER
+// ============================================================================
+
+class DateFnsLocaleLoader {
+  private findBestDateFnsLocale(
+    requestedLocale: string,
+    availableLocales: string[],
+  ): string | null {
+    // Try exact match
+    if (availableLocales.includes(requestedLocale)) {
+      return requestedLocale
     }
 
-    if (!sectionsByLocale[fileLocale]) {
-      sectionsByLocale[fileLocale] = []
+    // Try language code
+    const languageCode = getLanguageCode(requestedLocale)
+    if (availableLocales.includes(languageCode)) {
+      return languageCode
     }
 
-    sectionsByLocale[fileLocale].push({ section, content, priority })
-  }
+    // Fallback to en-GB (English with European formatting)
+    if (availableLocales.includes("en-GB")) {
+      return "en-GB"
+    }
 
-  return sectionsByLocale
-}
+    // Final fallback to en
+    if (availableLocales.includes("en")) {
+      return "en"
+    }
 
-const mergeSectionsByPriority = (
-  sectionsByLocale: Record<string, LocaleSection[]>
-): Record<string, any> => {
-  const mergedByLocale: Record<string, any> = {}
+    return null
+  }
 
-  Object.entries(sectionsByLocale).forEach(([locale, sections]) => {
-    // Sort by priority descending (highest number = lowest priority)
-    const sortedSections = sections.sort((a, b) => b.priority - a.priority)
+  async loadDateFnsLocales(requestedLocales: string[]): Promise<DateLocales> {
+    const availableDateFnsLocales = filterValidDateFnsLocales(
+      getAvailableLocales(dateFnsLocaleFiles),
+    )
 
-    // Deep merge from lowest to highest priority
-    mergedByLocale[locale] = sortedSections.reduce((merged, { content }) => {
-      return mergeDeepRight(merged, content || {})
-    }, {})
-  })
+    // Create mapping of requested locale -> best available locale
+    const localeMapping: Record<string, string> = {}
+    for (const requestedLocale of requestedLocales) {
+      const bestMatch = this.findBestDateFnsLocale(
+        requestedLocale,
+        availableDateFnsLocales,
+      )
+      if (bestMatch) {
+        localeMapping[requestedLocale] = bestMatch
+      }
+    }
 
-  return mergedByLocale
-}
+    // Load only the needed locale files
+    const neededLocales = [...new Set(Object.values(localeMapping))]
+    const dateLocales: DateLocales = {}
 
-const enrichMessagesWithFallbacks = (
-  enrichmentMap: LocaleEnrichmentMap,
-  mergedByLocale: Record<string, any>
-): Messages => {
-  const enrichedMessages: Messages = {}
-
-  Object.entries(enrichmentMap).forEach(([requestedLocale, fallbackChain]) => {
-    let localeMessages = {}
-
-    // Merge in reverse order (lowest priority first)
-    const reversedChain = [...fallbackChain].reverse()
-    reversedChain.forEach((sourceLocale) => {
-      if (mergedByLocale[sourceLocale]) {
-        localeMessages = mergeDeepRight(localeMessages, mergedByLocale[sourceLocale])
-        logger.orchestrator(`Merged ${sourceLocale} into ${requestedLocale}`)
-      }
-    })
+    for (const neededLocale of neededLocales) {
+      const filePath = Object.keys(dateFnsLocaleFiles).find(
+        (path) => extractLocaleFromPath(path) === neededLocale,
+      )
 
-    enrichedMessages[requestedLocale] = localeMessages
-  })
+      if (filePath) {
+        try {
+          const module = await dateFnsLocaleFiles[filePath]()
+          const dateFnsLocale = module.default || module
+
+          // Map this loaded locale to all requesting locales
+          for (const [requestedLocale, targetLocale] of Object.entries(
+            localeMapping,
+          )) {
+            if (targetLocale === neededLocale) {
+              dateLocales[requestedLocale] = dateFnsLocale
+            }
+          }
+        } catch (error) {
+          logger.error(`Failed to load date-fns locale ${filePath}:`, error)
+        }
+      }
+    }
 
-  return enrichedMessages
+    return dateLocales
+  }
 }
 
-const loadVuetifyLocales = async (
-  files: LocaleFileImports,
-  locales: string[],
-  messages: Messages
-): Promise<void> => {
-  for (const [filePath, importFn] of Object.entries(files)) {
-    const module = await importFn()
-    const vuetifyLocale = module.default || module
-    const shortLocale = extractLocaleFromFilePath(filePath)
-
-    // Find corresponding long locale(s)
-    const matchingLocales = locales.filter(
-      (locale) => getShortLocale(locale) === shortLocale
-    )
+// ============================================================================
+// FILE FILTERING
+// ============================================================================
 
-    matchingLocales.forEach((locale) => {
-      if (messages[locale]) {
-        messages[locale].$vuetify = vuetifyLocale
+class FileFilter {
+  static filterByLocales(targetLocales: string[]) {
+    return (files: LocaleFileImports): LocaleFileImports => {
+      const filtered: LocaleFileImports = {}
+
+      for (const [filePath, importFn] of Object.entries(files)) {
+        const fileLocale = extractLocaleFromPath(filePath)
+        if (targetLocales.includes(fileLocale)) {
+          filtered[filePath] = importFn
+        }
       }
-    })
+
+      return filtered
+    }
   }
 }
 
-const loadMessages = async (
-  locales: string[],
-  priorities: SectionPriorities
-): Promise<Messages> => {
-  const availableLocales = getAvailableLocales(i18nFiles)
-  const enrichmentMap = createLocaleEnrichmentMap(locales, availableLocales, "en-EU")
-
-  // Get all unique locales to load
-  const allLocalesToLoad = new Set<string>()
-  Object.values(enrichmentMap).forEach((fallbackChain) => {
-    fallbackChain.forEach((locale) => allLocalesToLoad.add(locale))
-  })
-
-  // Filter and load i18n files
-  const filteredI18nFiles = createLocaleFilter(Array.from(allLocalesToLoad))(i18nFiles)
-  const sectionsByLocale = await loadAndCategorizeI18nFiles(filteredI18nFiles, priorities)
-  const mergedByLocale = mergeSectionsByPriority(sectionsByLocale)
-  const messages = enrichMessagesWithFallbacks(enrichmentMap, mergedByLocale)
-
-  // Load Vuetify locales
-  const shortLocales = locales.map(getShortLocale)
-  const filteredVuetifyFiles = createLocaleFilter(shortLocales)(vuetifyLocaleFiles)
-  await loadVuetifyLocales(filteredVuetifyFiles, locales, messages)
-
-  return messages
-}
+// ============================================================================
+// MAIN ORCHESTRATOR
+// ============================================================================
 
-// Date-fns locale loading
-const loadDateFnsLocales = async (locales: string[]): Promise<DateLocales> => {
-  const filteredDateFnsFiles = createDateFnsLocaleFilter(locales)(dateFnsLocaleFiles)
-  const dateLocales: DateLocales = {}
-  const availableDateFnsLocales = getAvailableDateFnsLocales(dateFnsLocaleFiles)
-
-  for (const [filePath, importFn] of Object.entries(filteredDateFnsFiles)) {
-    const module = await importFn()
-    const dateFnsLocale = module.default || module
-    const actualLocale = extractLocaleFromFilePath(filePath)
-
-    // Map to all requesting locales that should use this date-fns locale
-    locales.forEach((requestedLocale) => {
-      const shouldUseThisLocale = 
-        requestedLocale === actualLocale ||
-        (getShortLocale(requestedLocale) === actualLocale && 
-         !availableDateFnsLocales.includes(requestedLocale)) ||
-        (actualLocale === "eu" && 
-         !availableDateFnsLocales.includes(requestedLocale) &&
-         !availableDateFnsLocales.includes(getShortLocale(requestedLocale)))
-
-      if (shouldUseThisLocale) {
-        dateLocales[requestedLocale] = dateFnsLocale
-      }
+class I18nOrchestrator {
+  private fallbackLocale = "en-EU"
+
+  private async determineInitialLocale(
+    availableLocales: string[],
+  ): Promise<string> {
+    const browserLocale = navigator.language
+    let initialLocale = this.fallbackLocale
+
+    // Use the same fallback logic as message loading
+    const enrichment = new LocaleEnrichment(
+      [browserLocale],
+      availableLocales,
+      this.fallbackLocale,
+    )
+    const enrichmentMap = enrichment.createEnrichmentMap()
+
+    if (
+      enrichmentMap[browserLocale] &&
+      enrichmentMap[browserLocale].length > 0
+    ) {
+      initialLocale = enrichmentMap[browserLocale][0] // Take the first (best) match
+      logger.orchestrator(`Initial locale: ${browserLocale} → ${initialLocale}`)
+    } else {
+      logger.orchestrator(
+        `No match found for ${browserLocale}, using fallback: ${initialLocale}`,
+      )
+    }
+
+    await $store.dispatch({
+      type: "ui/update",
+      payload: { locale: initialLocale },
     })
-  }
 
-  return dateLocales
-}
+    return initialLocale
+  }
 
-// Main initialization function
-const initI18n = async (): Promise<I18nInstance> => {
-  if (!i18nInstance) {
-    const fallbackLocale = "en-EU"
+  async initialize(): Promise<I18nInstance> {
     const { locales, priorities } = configService.getI18nConfig()
     const availableLocales = getAvailableLocales(i18nFiles)
-    
+
     logger.orchestrator("Configured locales:", locales)
     logger.orchestrator("Available locale files:", availableLocales)
 
-    // Load messages and date locales concurrently
+    // Create enrichment map for fallback chains
+    const enrichment = new LocaleEnrichment(
+      locales,
+      availableLocales,
+      this.fallbackLocale,
+    )
+    const enrichmentMap = enrichment.createEnrichmentMap()
+
+    // Get all locales we need to load (including fallbacks)
+    const allLocalesToLoad = new Set<string>()
+    Object.values(enrichmentMap).forEach((fallbackChain) => {
+      fallbackChain.forEach((locale) => allLocalesToLoad.add(locale))
+    })
+
+    // Load messages, Vuetify locales, and date-fns locales concurrently
     const [loadedMessages, loadedDateLocales] = await Promise.all([
-      loadMessages(locales, priorities),
-      loadDateFnsLocales(locales)
+      this.loadMessages(
+        Array.from(allLocalesToLoad),
+        enrichmentMap,
+        priorities,
+        locales,
+      ),
+      new DateFnsLocaleLoader().loadDateFnsLocales(locales),
     ])
 
     messages = loadedMessages
     dateLocale = loadedDateLocales
-    
+
     logger.orchestrator("Loaded messages:", Object.keys(messages))
     logger.orchestrator("Loaded date locales:", Object.keys(dateLocale))
 
-    // Create formats
-    const dateTimeFormats = createFormatsForLocales(locales, defaultDateTimeFormats)
-    const numberFormatsForLocales = createFormatsForLocales(locales, defaultNumberFormats)
-
-    // Initialize i18n instance
+    // Create i18n instance
+    const initialLocale = await this.determineInitialLocale(
+      Object.keys(messages),
+    )
     i18nInstance = createI18n({
       legacy: false,
       globalInjection: true,
-      locale: navigator.language,
-      fallbackLocale: fallbackLocale,
+      locale: initialLocale,
+      fallbackLocale: this.fallbackLocale,
       messages,
-      datetimeFormats: dateTimeFormats,
-      numberFormats: numberFormatsForLocales,
+      datetimeFormats: createFormatsForAllLocales(
+        locales,
+        defaultDateTimeFormats,
+      ),
+      numberFormats: createFormatsForAllLocales(locales, defaultNumberFormats),
     })
 
     instanceAdapter = {
-      adapter: createVueI18nAdapter({
-        i18n: i18nInstance,
-        useI18n,
-      }),
+      adapter: createVueI18nAdapter({ i18n: i18nInstance, useI18n }),
     }
+
+    return { i18nInstance, instanceAdapter, dateLocale }
   }
 
+  private async loadMessages(
+    localesToLoad: string[],
+    enrichmentMap: Record<string, string[]>,
+    priorities: SectionPriorities,
+    requestedLocales: string[],
+  ): Promise<Messages> {
+    // Filter i18n files and process messages
+    const filteredI18nFiles =
+      FileFilter.filterByLocales(localesToLoad)(i18nFiles)
+    const messageProcessor = new MessageProcessor(priorities)
+    const messages = await messageProcessor.processMessages(
+      filteredI18nFiles,
+      enrichmentMap,
+    )
+
+    // Load Vuetify locales
+    const shortLocales = requestedLocales.map(getLanguageCode)
+    const filteredVuetifyFiles =
+      FileFilter.filterByLocales(shortLocales)(vuetifyLocaleFiles)
+    const vuetifyLoader = new VuetifyLocaleLoader()
+    await vuetifyLoader.loadVuetifyLocales(
+      filteredVuetifyFiles,
+      requestedLocales,
+      messages,
+    )
+
+    return messages
+  }
+}
+
+// ============================================================================
+// PUBLIC API
+// ============================================================================
+
+const initI18n = async (): Promise<I18nInstance> => {
+  if (!i18nInstance) {
+    const orchestrator = new I18nOrchestrator()
+    return await orchestrator.initialize()
+  }
   return { i18nInstance, instanceAdapter, dateLocale }
 }
 
 export default initI18n
-export { i18nInstance, instanceAdapter, dateLocale, initI18n }
+export { i18nInstance, instanceAdapter, dateLocale, initI18n }