nuxt-i18n-micro 3.30.2 → 4.0.0

package/dist/runtime/server/utils/server-loader.js

@@ -1,65 +1,119 @@
 import { isEnabledLocale } from "@i18n-micro/utils/active-locales";
-import { normalizeConfiguredLocales, toPremergedStorageKey } from "@i18n-micro/utils/merge-source";
+import { mergeOverRoot, normalizeConfiguredLocales, PREMERGED_ROOT_PAGE, toPremergedStorageKey } from "@i18n-micro/utils/merge-source";
 import { fetchTranslationPayloadFromHost } from "@i18n-micro/utils/payload-fetch";
 import { resolveTranslationPayloadPage } from "@i18n-micro/utils/payload-url";
-import { resolveI18nConfigWithRuntimeOverrides } from "@i18n-micro/utils/runtime-config";
 import { loadSourceTranslationsFromStorage } from "@i18n-micro/utils/source-loader";
 import { toTranslations } from "@i18n-micro/utils/normalize";
-import { readPayload } from "#i18n-internal/payload-source";
+import { embeddedPayloads, readPayload } from "#i18n-internal/payload-source";
 import { getI18nPrivateConfig } from "#i18n-internal/config";
-import { getI18nConfig } from "#i18n-internal/strategy";
-import { loadLiveDevTranslations } from "./dev-live-translations.js";
-import { getOrCreateServerTranslationCache } from "./server-translation-cache.js";
-export async function loadTranslationsFromServer(locale, routeName) {
-  const cc = getOrCreateServerTranslationCache();
-  const cacheKey = `${locale}:${routeName}`;
-  const cached = cc.get(cacheKey);
-  if (cached) {
-    return cached;
+import { loadLiveDevTranslations } from "../internal/dev-live-translations.js";
+import { getI18nServerConfig } from "./locale-detector.js";
+import { getOrCreateServerTranslationCache } from "../internal/server-translation-cache.js";
+import { readSharedChunk, sharedChunkKey, writeSharedChunk } from "../internal/shared-cache.js";
+import { takeRootMark, toEntry } from "../../utils/translation-entry.js";
+const EMPTY = { data: {}, json: "{}" };
+export const NO_FILE = { data: {}, json: "{}" };
+const pending = /* @__PURE__ */ new Map();
+const requestBoundIo = typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers";
+function runtimeHost() {
+  try {
+    return process.env.NUXT_I18N_APP_BASE_SERVER_HOST;
+  } catch {
+    return void 0;
   }
-  const config = resolveI18nConfigWithRuntimeOverrides(getI18nConfig());
-  const privateConfig = getI18nPrivateConfig();
-  if (!isEnabledLocale(config.locales, locale)) {
-    const empty = { data: {}, json: "{}" };
-    cc.set(cacheKey, empty);
-    return empty;
+}
+export function resolveServerHost() {
+  return runtimeHost() ?? getI18nPrivateConfig().apiBaseServerHost;
+}
+export async function loadTranslationsFromServer(locale, routeName) {
+  const config = getI18nServerConfig();
+  if (!isEnabledLocale(config.locales, locale)) return EMPTY;
+  const page = resolveTranslationPayloadPage(routeName, config.routesLocaleLinks || {});
+  if (import.meta.dev && !resolveServerHost()) return toEntry(await loadLiveDevTranslations(locale, page, config));
+  return cached(`${locale}:${page}`, () => readChunk(locale, page, config));
+}
+function cached(key, read) {
+  const cache = getOrCreateServerTranslationCache();
+  const hit = cache.get(key);
+  if (hit) return Promise.resolve(hit);
+  const inFlight = requestBoundIo && !isEmbeddedRead() ? void 0 : pending.get(key);
+  if (inFlight) return inFlight;
+  const promise = read().then(({ entry, shared }) => {
+    if (!shared) cache.set(key, entry);
+    return entry;
+  }).finally(() => pending.delete(key));
+  pending.set(key, promise);
+  return promise;
+}
+const isEmbeddedRead = () => embeddedPayloads && !resolveServerHost();
+const rootChunk = (locale, config) => cached(`${locale}:${PREMERGED_ROOT_PAGE}`, () => readChunk(locale, PREMERGED_ROOT_PAGE, config));
+function readChunk(locale, page, config) {
+  const key = isEmbeddedRead() ? null : sharedChunkKey(locale, page, config, resolveServerHost());
+  return key ? readThroughShared(key, locale, page, config) : load(locale, page, config);
+}
+async function readThroughShared(key, locale, page, config) {
+  const hit = await readSharedChunk(key);
+  if (hit) return { entry: hit };
+  const loaded = await load(locale, page, config);
+  const { entry, shared, partial, marked } = loaded;
+  if (entry === NO_FILE || partial) return loaded;
+  if (shared) return { entry };
+  const json = JSON.stringify(entry.data);
+  if (json === "{}") return { entry };
+  if (page === PREMERGED_ROOT_PAGE) {
+    await writeSharedChunk(key, json, config);
+    return { entry };
   }
-  const routesLocaleLinks = config.routesLocaleLinks || {};
-  const resolvedPage = resolveTranslationPayloadPage(routeName, routesLocaleLinks);
-  if (privateConfig.apiBaseServerHost) {
-    const data2 = await fetchTranslationPayloadFromHost(
-      { apiBaseUrl: config.apiBaseUrl, apiBaseServerHost: privateConfig.apiBaseServerHost, dateBuild: config.dateBuild },
+  const root = await rootChunk(locale, config).catch(() => null);
+  if (!root || !Object.keys(root.data).length) return { entry };
+  if (!marked && JSON.stringify(root.data) === json) return { entry: root };
+  if (Object.keys(root.data).every((rootKey) => Object.hasOwn(entry.data, rootKey))) await writeSharedChunk(key, json, config);
+  return { entry };
+}
+function toEntryWithMark(data, mark) {
+  const entry = toEntry(data);
+  entry.mark = mark;
+  return entry;
+}
+async function load(locale, page, config) {
+  const apiBaseServerHost = resolveServerHost();
+  if (apiBaseServerHost) {
+    const data = await fetchTranslationPayloadFromHost(
+      { apiBaseUrl: config.apiBaseUrl, apiBaseServerHost, dateBuild: config.dateBuild },
       locale,
-      resolvedPage,
+      page,
       $fetch
     );
-    const json2 = JSON.stringify(data2).replace(/</g, "\\u003c");
-    const entry2 = { data: data2, json: json2 };
-    cc.set(cacheKey, entry2);
-    return entry2;
+    return data ? settle(locale, page, data, config) : { entry: NO_FILE, shared: true };
   }
-  let data;
-  if (import.meta.dev) {
-    data = await loadLiveDevTranslations(locale, resolvedPage, config);
-  } else {
-    const mode = config.translationPayloadMode === "source" ? "source" : "premerged";
-    if (mode === "source") {
-      data = await loadSourceTranslationsFromStorage(
-        { getItem: (key) => readPayload(key) },
-        {
-          locale,
-          pageName: resolvedPage,
-          locales: normalizeConfiguredLocales(config.locales),
-          globalFallbackLocale: config.fallbackLocale,
-          disablePageLocales: config.disablePageLocales
-        }
-      );
-    } else {
-      data = toTranslations(await readPayload(toPremergedStorageKey(resolvedPage, locale)));
-    }
+  if (config.translationPayloadMode === "source") {
+    const data = await loadSourceTranslationsFromStorage(
+      { getItem: (key) => readPayload(key) },
+      {
+        locale,
+        pageName: page,
+        // a fallback may live on another domain: its file is still this build's
+        locales: normalizeConfiguredLocales(config.linkLocales ?? config.locales),
+        globalFallbackLocale: config.fallbackLocale,
+        disablePageLocales: config.disablePageLocales
+      }
+    );
+    return { entry: toEntry(data) };
   }
-  const json = JSON.stringify(data).replace(/</g, "\\u003c");
-  const entry = { data, json };
-  cc.set(cacheKey, entry);
-  return entry;
+  const own = toTranslations(await readPayload(toPremergedStorageKey(page, locale)));
+  if (Object.keys(own).length || page === PREMERGED_ROOT_PAGE) return settle(locale, page, own, config);
+  return { entry: await rootChunk(locale, config), shared: true };
+}
+async function settle(locale, page, file, config) {
+  const mark = takeRootMark(file);
+  if (!mark) return { entry: toEntry(file) };
+  if (page === PREMERGED_ROOT_PAGE) return { entry: toEntryWithMark(file, mark) };
+  let root = await rootChunk(locale, config);
+  if (root.mark && root.mark !== mark) {
+    getOrCreateServerTranslationCache().delete(`${locale}:${PREMERGED_ROOT_PAGE}`);
+    root = await rootChunk(locale, config);
+  }
+  const merged = mergeOverRoot(root.data, file);
+  const entry = merged === root.data ? root : toEntry(merged);
+  return root === NO_FILE ? { entry, shared: true, partial: true } : { entry, marked: true };
 }

package/dist/runtime/server/utils/translation-server-middleware.js

@@ -1,44 +1,27 @@
 import { interpolate, resolveTranslation } from "@i18n-micro/core";
-import { getEnabledLocales } from "@i18n-micro/utils/active-locales";
-import { resolveI18nConfigWithRuntimeOverrides } from "@i18n-micro/utils/runtime-config";
-import { getI18nConfig } from "#i18n-internal/strategy";
-import { useRuntimeConfig } from "#imports";
-import { detectCurrentLocale } from "./locale-detector.js";
+import { getI18nServerConfig, getRequestLocale } from "./locale-detector.js";
 import { loadTranslationsFromServer } from "./server-loader.js";
 const I18N_CONTEXT_KEY = "__i18n_translations__";
-export const useTranslationServerMiddleware = async (event, defaultLocale, currentLocale) => {
-  const config = resolveI18nConfigWithRuntimeOverrides(
-    getI18nConfig(),
-    useRuntimeConfig(event).public
-  );
-  const { locales, fallbackLocale, defaultLocale: configDefaultLocale } = config;
-  const locale = currentLocale || event.context.i18n?.locale || detectCurrentLocale(
-    event,
-    {
-      fallbackLocale,
-      defaultLocale: defaultLocale || configDefaultLocale,
-      locales: getEnabledLocales(locales),
-      localeCookie: config.localeCookie,
-      autoDetectLanguage: config.autoDetectLanguage
-    },
-    defaultLocale
-  );
-  if (!event.context[I18N_CONTEXT_KEY]) {
-    let translations2;
-    if (event.context.i18n?.translations && Object.keys(event.context.i18n.translations).length > 0) {
-      translations2 = event.context.i18n.translations;
-    } else {
-      const { data } = await loadTranslationsFromServer(locale, "index");
-      translations2 = data;
-    }
-    event.context[I18N_CONTEXT_KEY] = translations2;
+async function dictionaryOf(event, locale) {
+  const loaded = event.context[I18N_CONTEXT_KEY] ??= /* @__PURE__ */ Object.create(null);
+  const own = loaded[locale];
+  if (own) return own;
+  const page = event.context.i18n;
+  const preloaded = page?.locale === locale && page.translations && Object.keys(page.translations).length > 0 ? page.translations : null;
+  if (preloaded) return loaded[locale] = preloaded;
+  const chunk = await loadTranslationsFromServer(locale, "index").catch(() => null);
+  if (!chunk) {
+    console.warn("[i18n] Translation load failed:", locale, "index");
+    return {};
   }
-  const translations = event.context[I18N_CONTEXT_KEY];
+  return loaded[locale] = chunk.data;
+}
+export const useTranslationServerMiddleware = async (event, defaultLocale, currentLocale) => {
+  const locale = currentLocale || getRequestLocale(event, getI18nServerConfig(event), defaultLocale);
+  const translations = await dictionaryOf(event, locale);
   function t(key, params, defaultValue) {
     const value = resolveTranslation(translations, key);
-    if (value === null) {
-      return defaultValue || key;
-    }
+    if (value === null) return defaultValue && params ? interpolate(defaultValue, params) : defaultValue || key;
     const str = typeof value === "string" ? value : String(value);
     return params ? interpolate(str, params) : str;
   }

package/dist/runtime/utils/cache-keys.d.ts

@@ -0,0 +1,6 @@
+export declare const STORAGE_CC_KEY: unique symbol;
+/**
+ * Entries the server keeps when `cacheMaxSize` is not set. Never unbounded: every distinct
+ * `locale:page` a request names would otherwise stay in memory for the life of the process.
+ */
+export declare const DEFAULT_SERVER_CACHE_SIZE = 1000;

package/dist/runtime/utils/cache-keys.js

@@ -0,0 +1,2 @@
+export const STORAGE_CC_KEY = Symbol.for("__NUXT_I18N_STORAGE_CC__");
+export const DEFAULT_SERVER_CACHE_SIZE = 1e3;

package/dist/runtime/utils/i18n-api.d.ts

@@ -0,0 +1,185 @@
+import type { PathStrategy, ResolvedRouteLike, RouteLike } from '@i18n-micro/path-strategy';
+import type { DefineI18nRouteConfig, I18nRouteParams, MissingHandler, ResolvedI18nConfig, Translations } from '@i18n-micro/types';
+import type { RouteLocationNamedRaw, RouteLocationNormalizedLoaded, RouteLocationResolved, RouteLocationResolvedGeneric, Router } from 'vue-router';
+import type { useI18nLocale } from '../composables/useI18nLocale.js';
+import type { NuxtI18n, NuxtTranslationLoader } from './nuxt-i18n.js';
+/** URL of a switch result: the strategy hands out a URL string or a resolved route (fullPath set). */
+export declare function switchedPath(switched: RouteLike | string): string;
+export interface NuxtI18nPluginApiDeps {
+    i18n: NuxtI18n;
+    loader: NuxtTranslationLoader;
+    i18nStrategy: PathStrategy;
+    i18nConfig: ResolvedI18nConfig;
+    router: Router;
+    locale: ReturnType<typeof useI18nLocale>;
+    getCurrentLocale: (route?: ResolvedRouteLike) => string;
+    i18nRouteParams: {
+        value: I18nRouteParams;
+    };
+    navigateTo: (to: string, options?: {
+        redirectCode?: number;
+        external?: boolean;
+    }) => unknown;
+    setMissingHandler: (handler: MissingHandler | null) => void;
+    isHydrating: () => boolean;
+}
+export declare function createNuxtI18nPluginApi(deps: NuxtI18nPluginApiDeps): {
+    helper: {
+        mergeTranslation(locale: string, routeName: string, newTranslations: Translations): Promise<void>;
+    };
+    provide: {
+        i18nStrategy: PathStrategy;
+        getLocale: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => string;
+        getLocaleName: () => string | null;
+        defaultLocale: () => string;
+        getLocales: () => import("@i18n-micro/types").Locale[];
+        getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, _locale?: string) => string;
+        t: (key: import("@i18n-micro/types").TranslationKey, params?: import("@i18n-micro/types").Params, defaultValue?: string | null, routeContext?: unknown) => import("@i18n-micro/types").CleanTranslation;
+        ts: (key: import("@i18n-micro/types").TranslationKey, params?: import("@i18n-micro/types").Params, defaultValue?: string, routeContext?: unknown) => string;
+        _t: (route: RouteLocationNormalizedLoaded) => import("./nuxt-i18n.js").TranslationFn<import("@i18n-micro/types").CleanTranslation>;
+        _ts: (route: RouteLocationNormalizedLoaded) => import("./nuxt-i18n.js").TranslationFn<string>;
+        tc: (key: import("@i18n-micro/types").TranslationKey, count: number | import("@i18n-micro/types").Params, defaultValue?: string) => string;
+        pluralFunc: import("@i18n-micro/types").PluralFunc;
+        pluralLocale: () => string;
+        tn: {
+            (value: number, options?: Intl.NumberFormatOptions): string;
+            (value: number, key: string, overrides?: Intl.NumberFormatOptions): string;
+            (value: number, key: string, locale: string, overrides?: Intl.NumberFormatOptions): string;
+        };
+        td: {
+            (value: Date | number | string, options?: Intl.DateTimeFormatOptions): string;
+            (value: Date | number | string, key: string, overrides?: Intl.DateTimeFormatOptions): string;
+            (value: Date | number | string, key: string, locale: string, overrides?: Intl.DateTimeFormatOptions): string;
+        };
+        tdr: (value: Date | number | string, options?: Intl.RelativeTimeFormatOptions) => string;
+        has: (key: import("@i18n-micro/types").TranslationKey, routeContext?: unknown) => boolean;
+        resolveTranslations: (routeContext?: unknown) => Translations;
+        setTranslation: (key: import("@i18n-micro/types").TranslationKey, value: unknown) => void;
+        mergeTranslations: (newTranslations: Translations) => void;
+        switchLocaleRoute: (toLocale: string) => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric;
+        clearCache: () => void;
+        switchLocalePath: (toLocale: string) => string;
+        switchLocale: (toLocale: string) => Promise<boolean>;
+        switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => Promise<unknown>;
+        localeRoute(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): RouteLocationResolved;
+        localePath(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): string;
+        setI18nRouteParams: (value: I18nRouteParams) => I18nRouteParams;
+        loadPageTranslations: (locale: string, routeName: string, translations: Translations) => Promise<void>;
+        setMissingHandler: (handler: MissingHandler | null) => void;
+    };
+};
+export type NuxtI18nPluginApi = ReturnType<typeof createNuxtI18nPluginApi>;
+export type NuxtI18nPluginProvide = NuxtI18nPluginApi['provide'];
+/** The page's own translations: on the active locale, and again on each switch while the page lives. */
+declare function createDefineI18nRoute({ getLocale, mergeTranslations }: Pick<NuxtI18nPluginProvide, 'getLocale' | 'mergeTranslations'>): ({ locales }: DefineI18nRouteConfig) => Promise<void>;
+export interface I18nProvideDeps {
+    api: NuxtI18nPluginApi;
+    i18nConfig: ResolvedI18nConfig;
+    router: Router;
+    i18nRouteParams: {
+        value: I18nRouteParams;
+    };
+}
+/**
+ * What the plugin provides: each helper as `$name` on the app, and under both spellings in `useI18n()`.
+ * `install` is apart so that the plugin's return type, which `NuxtApp` is made of, does not depend on `NuxtApp`.
+ */
+export declare function createI18nProvide({ api: { helper, provide }, i18nConfig, router, i18nRouteParams }: I18nProvideDeps): {
+    provide: {
+        i18n: {
+            helper: {
+                mergeTranslation(locale: string, routeName: string, newTranslations: Translations): Promise<void>;
+            };
+            getI18nConfig: () => ResolvedI18nConfig;
+            __micro: boolean;
+            i18nStrategy: PathStrategy;
+            getLocale: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => string;
+            getLocaleName: () => string | null;
+            defaultLocale: () => string;
+            getLocales: () => import("@i18n-micro/types").Locale[];
+            getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, _locale?: string) => string;
+            t: (key: import("@i18n-micro/types").TranslationKey, params?: import("@i18n-micro/types").Params, defaultValue?: string | null, routeContext?: unknown) => import("@i18n-micro/types").CleanTranslation;
+            ts: (key: import("@i18n-micro/types").TranslationKey, params?: import("@i18n-micro/types").Params, defaultValue?: string, routeContext?: unknown) => string;
+            _t: (route: RouteLocationNormalizedLoaded) => import("./nuxt-i18n.js").TranslationFn<import("@i18n-micro/types").CleanTranslation>;
+            _ts: (route: RouteLocationNormalizedLoaded) => import("./nuxt-i18n.js").TranslationFn<string>;
+            tc: (key: import("@i18n-micro/types").TranslationKey, count: number | import("@i18n-micro/types").Params, defaultValue?: string) => string;
+            pluralFunc: import("@i18n-micro/types").PluralFunc;
+            pluralLocale: () => string;
+            tn: {
+                (value: number, options?: Intl.NumberFormatOptions): string;
+                (value: number, key: string, overrides?: Intl.NumberFormatOptions): string;
+                (value: number, key: string, locale: string, overrides?: Intl.NumberFormatOptions): string;
+            };
+            td: {
+                (value: Date | number | string, options?: Intl.DateTimeFormatOptions): string;
+                (value: Date | number | string, key: string, overrides?: Intl.DateTimeFormatOptions): string;
+                (value: Date | number | string, key: string, locale: string, overrides?: Intl.DateTimeFormatOptions): string;
+            };
+            tdr: (value: Date | number | string, options?: Intl.RelativeTimeFormatOptions) => string;
+            has: (key: import("@i18n-micro/types").TranslationKey, routeContext?: unknown) => boolean;
+            resolveTranslations: (routeContext?: unknown) => Translations;
+            setTranslation: (key: import("@i18n-micro/types").TranslationKey, value: unknown) => void;
+            mergeTranslations: (newTranslations: Translations) => void;
+            switchLocaleRoute: (toLocale: string) => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric;
+            clearCache: () => void;
+            switchLocalePath: (toLocale: string) => string;
+            switchLocale: (toLocale: string) => Promise<boolean>;
+            switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => Promise<unknown>;
+            localeRoute(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): RouteLocationResolved;
+            localePath(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): string;
+            loadPageTranslations: (locale: string, routeName: string, translations: Translations) => Promise<void>;
+            setMissingHandler: (handler: MissingHandler | null) => void;
+        };
+        defineI18nRoute: ReturnType<typeof createDefineI18nRoute>;
+        helper: {
+            mergeTranslation(locale: string, routeName: string, newTranslations: Translations): Promise<void>;
+        };
+        getI18nConfig: () => ResolvedI18nConfig;
+        __micro: boolean;
+        i18nStrategy: PathStrategy;
+        getLocale: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => string;
+        getLocaleName: () => string | null;
+        defaultLocale: () => string;
+        getLocales: () => import("@i18n-micro/types").Locale[];
+        getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, _locale?: string) => string;
+        t: (key: import("@i18n-micro/types").TranslationKey, params?: import("@i18n-micro/types").Params, defaultValue?: string | null, routeContext?: unknown) => import("@i18n-micro/types").CleanTranslation;
+        ts: (key: import("@i18n-micro/types").TranslationKey, params?: import("@i18n-micro/types").Params, defaultValue?: string, routeContext?: unknown) => string;
+        _t: (route: RouteLocationNormalizedLoaded) => import("./nuxt-i18n.js").TranslationFn<import("@i18n-micro/types").CleanTranslation>;
+        _ts: (route: RouteLocationNormalizedLoaded) => import("./nuxt-i18n.js").TranslationFn<string>;
+        tc: (key: import("@i18n-micro/types").TranslationKey, count: number | import("@i18n-micro/types").Params, defaultValue?: string) => string;
+        pluralFunc: import("@i18n-micro/types").PluralFunc;
+        pluralLocale: () => string;
+        tn: {
+            (value: number, options?: Intl.NumberFormatOptions): string;
+            (value: number, key: string, overrides?: Intl.NumberFormatOptions): string;
+            (value: number, key: string, locale: string, overrides?: Intl.NumberFormatOptions): string;
+        };
+        td: {
+            (value: Date | number | string, options?: Intl.DateTimeFormatOptions): string;
+            (value: Date | number | string, key: string, overrides?: Intl.DateTimeFormatOptions): string;
+            (value: Date | number | string, key: string, locale: string, overrides?: Intl.DateTimeFormatOptions): string;
+        };
+        tdr: (value: Date | number | string, options?: Intl.RelativeTimeFormatOptions) => string;
+        has: (key: import("@i18n-micro/types").TranslationKey, routeContext?: unknown) => boolean;
+        resolveTranslations: (routeContext?: unknown) => Translations;
+        setTranslation: (key: import("@i18n-micro/types").TranslationKey, value: unknown) => void;
+        mergeTranslations: (newTranslations: Translations) => void;
+        switchLocaleRoute: (toLocale: string) => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric;
+        clearCache: () => void;
+        switchLocalePath: (toLocale: string) => string;
+        switchLocale: (toLocale: string) => Promise<boolean>;
+        switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => Promise<unknown>;
+        localeRoute(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): RouteLocationResolved;
+        localePath(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): string;
+        loadPageTranslations: (locale: string, routeName: string, translations: Translations) => Promise<void>;
+        setMissingHandler: (handler: MissingHandler | null) => void;
+    };
+    install: (nuxtApp: {
+        vueApp: {
+            config: {
+                globalProperties: Record<string, unknown>;
+            };
+        };
+    }) => void;
+};
+export {};

package/dist/runtime/utils/i18n-api.js

@@ -0,0 +1,196 @@
+import { isNoPrefixStrategy, urlPath } from "@i18n-micro/core";
+import { trimTrailingSlashes } from "@i18n-micro/utils/app-path";
+import { hasProtocol } from "ufo";
+import { getCurrentInstance, onActivated, watch } from "vue";
+import { domains, defineRoute, serverPathFallback } from "#build/i18n.strategy.mjs";
+import { usePageRoute } from "./page-head.js";
+import { applyTrailingSlash } from "./trailing-slash.js";
+function toRouteLocationResolved(result) {
+  const fullPath = result.fullPath ?? result.path ?? "";
+  const path = result.path ?? urlPath(fullPath);
+  const out = { path, fullPath, href: fullPath };
+  if (result.name) out.name = result.name;
+  if (result.params && Object.keys(result.params).length) out.params = result.params;
+  if (result.query && Object.keys(result.query).length) out.query = result.query;
+  if (result.hash) out.hash = result.hash;
+  return out;
+}
+const URL_SCHEME = /^(?:https?:|mailto:|tel:)/i;
+const DUPLICATED = 16;
+const ABORTED = 4;
+const APP_SCHEME = /^(?:mailto:|tel:)/i;
+export function switchedPath(switched) {
+  return typeof switched === "string" ? switched : switched.fullPath ?? switched.path ?? "";
+}
+export function createNuxtI18nPluginApi(deps) {
+  const {
+    i18n,
+    loader,
+    i18nStrategy,
+    i18nConfig,
+    router,
+    locale: localeState,
+    getCurrentLocale,
+    i18nRouteParams,
+    navigateTo,
+    setMissingHandler,
+    isHydrating
+  } = deps;
+  const { getEffectiveLocale, setLocale, isValidLocale } = localeState;
+  const setLocaleState = (code) => {
+    localeState.locale.value = code;
+  };
+  const isNoPrefix = isNoPrefixStrategy(i18nConfig.strategy);
+  const withSlashRule = (switched) => i18nConfig.trailingSlash ? applyTrailingSlash(switchedPath(switched), i18nConfig.trailingSlash) : switched;
+  const linkRoute = () => {
+    const route = router.currentRoute.value;
+    if (!route.hash || !isHydrating()) return route;
+    return { ...route, hash: "", fullPath: route.fullPath.slice(0, route.fullPath.indexOf("#")) };
+  };
+  const switchedLink = (toLocale) => i18nStrategy.switchLocaleRoute(toLocale, linkRoute(), { i18nRouteParams: i18nRouteParams.value });
+  const isUrl = (to) => typeof to === "string" && URL_SCHEME.test(to);
+  const localized = (to, locale) => i18nStrategy.localeRoute(locale !== void 0 && locale !== "" ? String(locale) : getCurrentLocale(), to);
+  const switchLocaleLogic = (toLocale, i18nParams, to) => {
+    if (typeof to === "string" && APP_SCHEME.test(to)) return navigateTo(to, { redirectCode: 200, external: true });
+    const from = typeof to === "string" ? i18nStrategy.localeRoute(getCurrentLocale(), to) : to ?? router.currentRoute.value;
+    const switchedRoute = i18nStrategy.switchLocaleRoute(toLocale, from, {
+      i18nRouteParams: i18nParams,
+      named: isNoPrefix
+    });
+    const url = switchedPath(switchedRoute);
+    const domainUrl = i18nConfig.locales?.find((locale) => locale.code === toLocale)?.baseUrl;
+    const domain = domainUrl && trimTrailingSlashes(domainUrl);
+    if (domain && (url === domain || url.startsWith(`${domain}/`))) return navigateTo(url, { redirectCode: 200, external: true });
+    if (isNoPrefix) {
+      const { path, fullPath, ...named } = switchedRoute;
+      return router.replace({ ...named.name ? named : { path, fullPath, ...named }, force: true });
+    }
+    return router.push(withSlashRule(switchedRoute));
+  };
+  const settleSwitch = (toLocale, failure) => {
+    const type = failure instanceof Error ? failure.type : void 0;
+    const reloaded = serverPathFallback && type === ABORTED && !i18nStrategy.probe(provide.switchLocalePath(toLocale))?.matched?.length;
+    if (reloaded) setLocale(toLocale);
+    else if (failure instanceof Error && type !== DUPLICATED) setLocaleState(i18n.getLocale());
+    else if (type === DUPLICATED || i18n.getLocale() === toLocale) setLocale(toLocale);
+  };
+  const helper = {
+    async mergeTranslation(locale, routeName, newTranslations) {
+      await i18n.mergeTranslationAsync(locale, routeName, newTranslations, (l, r) => loader.loadAsync(l, r));
+    }
+  };
+  const provide = {
+    i18nStrategy,
+    getLocale: (route) => getEffectiveLocale(route, (r) => getCurrentLocale(r)),
+    getLocaleName: () => i18nStrategy.getCurrentLocaleName(router.currentRoute.value, getCurrentLocale() ?? null),
+    defaultLocale: () => i18nConfig.defaultLocale,
+    getLocales: () => i18nConfig.locales,
+    getRouteName: (route, _locale) => i18nStrategy.getRouteBaseName(route ?? router.currentRoute.value) ?? "",
+    t: i18n.t.bind(i18n),
+    ts: i18n.ts.bind(i18n),
+    _t: (route) => i18n.tForRoute(route),
+    _ts: (route) => i18n.tsForRoute(route),
+    tc: i18n.tc.bind(i18n),
+    pluralFunc: i18n.pluralFunc,
+    pluralLocale: i18n.pluralLocale.bind(i18n),
+    tn: i18n.tn.bind(i18n),
+    td: i18n.td.bind(i18n),
+    tdr: i18n.tdr.bind(i18n),
+    has: i18n.has.bind(i18n),
+    resolveTranslations: i18n.resolveTranslations.bind(i18n),
+    setTranslation: i18n.setTranslation.bind(i18n),
+    mergeTranslations: i18n.mergeTranslations.bind(i18n),
+    switchLocaleRoute: (toLocale) => {
+      const switched = switchedLink(toLocale);
+      if (typeof switched === "string" || !i18nConfig.trailingSlash) return switched;
+      const fullPath = applyTrailingSlash(switchedPath(switched), i18nConfig.trailingSlash);
+      return { path: urlPath(fullPath), fullPath, query: switched.query, hash: switched.hash };
+    },
+    clearCache: () => {
+      void loader.reload();
+    },
+    switchLocalePath: (toLocale) => applyTrailingSlash(switchedPath(switchedLink(toLocale)), i18nConfig.trailingSlash),
+    switchLocale: async (toLocale) => {
+      if (!isValidLocale(toLocale)) {
+        if (process.env.NODE_ENV !== "production") console.warn(`[i18n] Invalid locale '${toLocale}'`);
+        return false;
+      }
+      const urlless = isNoPrefix || i18nConfig.hashMode;
+      const retry = getCurrentLocale() === toLocale && i18n.getLocale() !== toLocale;
+      const route = router.currentRoute.value;
+      const loaded = urlless || retry ? await loader.switchContext(toLocale, i18nStrategy.getPluginRouteName(route, toLocale)) : null;
+      if (loaded === false) return false;
+      if (urlless || hasProtocol(provide.switchLocalePath(toLocale))) setLocale(toLocale);
+      else setLocaleState(toLocale);
+      try {
+        const failure = await switchLocaleLogic(toLocale, i18nRouteParams.value);
+        if (!urlless) settleSwitch(toLocale, failure);
+      } catch (error) {
+        if (!urlless) setLocaleState(i18n.getLocale());
+        throw error;
+      }
+      return loaded ?? i18n.getLocale() === toLocale;
+    },
+    switchRoute: async (route, toLocale) => {
+      return switchLocaleLogic(toLocale ?? getCurrentLocale(), i18nRouteParams.value, route);
+    },
+    localeRoute(to, locale) {
+      return toRouteLocationResolved(isUrl(to) ? { path: to, fullPath: to } : localized(to, locale));
+    },
+    localePath(to, locale) {
+      return isUrl(to) ? to : applyTrailingSlash(switchedPath(localized(to, locale)), i18nConfig.trailingSlash);
+    },
+    setI18nRouteParams: (value) => {
+      i18nRouteParams.value = value;
+      return i18nRouteParams.value;
+    },
+    loadPageTranslations: i18n.loadPageTranslations.bind(i18n),
+    setMissingHandler
+  };
+  if (domains) {
+    const { switchLocale } = provide;
+    provide.switchLocale = async (code) => {
+      if (isValidLocale(code) || !i18nConfig.linkLocales?.some((locale) => locale.code === code && !locale.disabled)) return switchLocale(code);
+      await navigateTo(provide.switchLocalePath(code), { external: true });
+      return true;
+    };
+  }
+  return { helper, provide };
+}
+function createDefineI18nRoute({ getLocale, mergeTranslations }) {
+  return async ({ locales }) => {
+    if (!locales || Array.isArray(locales)) return;
+    const apply = () => {
+      const translations = locales[getLocale()];
+      if (translations) mergeTranslations(translations);
+    };
+    apply();
+    if (import.meta.client) watch(() => getLocale(), apply);
+  };
+}
+export function createI18nProvide({ api: { helper, provide }, i18nConfig, router, i18nRouteParams }) {
+  const { setI18nRouteParams, ...provided } = provide;
+  const pageRouteParams = {
+    enumerable: true,
+    get: () => {
+      const page = getCurrentInstance() && usePageRoute();
+      if (!page) return setI18nRouteParams;
+      let own;
+      onActivated(() => own && setI18nRouteParams(own));
+      return (value) => {
+        if (page.path !== router.currentRoute.value.path) return i18nRouteParams.value;
+        own = value;
+        return setI18nRouteParams(value);
+      };
+    }
+  };
+  const bound = { ...provided, helper, getI18nConfig: () => i18nConfig, __micro: true };
+  const dollar = Object.fromEntries(Object.entries(bound).map(([key, value]) => [`$${key}`, value]));
+  const spellings = Object.defineProperties({ ...bound, ...dollar }, { setI18nRouteParams: pageRouteParams, $setI18nRouteParams: pageRouteParams });
+  const install = (nuxtApp) => {
+    Object.defineProperty(nuxtApp, "$setI18nRouteParams", pageRouteParams);
+    nuxtApp.vueApp.config.globalProperties.$setI18nRouteParams = setI18nRouteParams;
+  };
+  const define = defineRoute ? { defineI18nRoute: createDefineI18nRoute(provide) } : {};
+  return { provide: { ...bound, ...define, i18n: spellings }, install };
+}

package/dist/runtime/utils/i18n-config.d.ts

@@ -0,0 +1,18 @@
+import type { ModuleOptionsExtend, ResolvedI18nConfig } from '@i18n-micro/types';
+import { type RuntimeI18nOverrides } from '@i18n-micro/utils/runtime-config';
+import type { NuxtApp } from 'nuxt/app';
+/** What the server resolved: overrides and the host. */
+type Shipped = RuntimeI18nOverrides & {
+    domain?: string;
+};
+/**
+ * What the browser has to be told, or null when the server resolved what the build says. By value:
+ * Nitro and the app bundle each hold their own copy of the build config, so `config !== base` is always true.
+ */
+export declare function shippedOverrides(config: ModuleOptionsExtend, base: ModuleOptionsExtend): Shipped | null;
+/**
+ * The module config with runtime overrides, the same on server and client: routing (the path
+ * strategy), validation (`useI18nLocale`) and redirects all read this one.
+ */
+export declare function useResolvedI18nConfig(nuxtApp: NuxtApp): ResolvedI18nConfig;
+export {};