nuxt-i18n-micro 3.30.2 → 4.0.0

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

@@ -0,0 +1,47 @@
+import {
+  applyI18nRuntimeOverrides,
+  createI18nConfigResolver,
+  readI18nRuntimeOverrides
+} from "@i18n-micro/utils/runtime-config";
+import { useState } from "#app/composables/state";
+import { configForHost } from "@i18n-micro/utils/domains";
+import { domains, getI18nConfig } from "#build/i18n.strategy.mjs";
+const configs = /* @__PURE__ */ new WeakMap();
+const resolveOnServer = import.meta.server ? createI18nConfigResolver() : void 0;
+const silent = () => {
+};
+function overridesOf(config) {
+  return {
+    defaultLocale: config.defaultLocale,
+    fallbackLocale: config.fallbackLocale,
+    disabledLocales: (config.locales ?? []).filter((locale) => locale.disabled).map((locale) => locale.code),
+    domain: config.domain,
+    dateBuild: String(config.dateBuild)
+  };
+}
+export function shippedOverrides(config, base) {
+  const shipped = overridesOf(config);
+  const built = overridesOf(base);
+  const same = shipped.defaultLocale === built.defaultLocale && shipped.fallbackLocale === built.fallbackLocale && shipped.domain === built.domain && shipped.dateBuild === built.dateBuild && String(shipped.disabledLocales) === String(built.disabledLocales);
+  return same ? null : shipped;
+}
+function resolve(nuxtApp) {
+  const base = getI18nConfig();
+  const shipped = useState("i18n-runtime-overrides", () => null);
+  if (import.meta.server) {
+    const config2 = nuxtApp.ssrContext?.event?.context?.i18n?.config ?? resolveOnServer(base, nuxtApp.$config.public);
+    shipped.value = shippedOverrides(config2, base);
+    return config2;
+  }
+  if (nuxtApp.payload.serverRendered) {
+    const config2 = shipped.value ? applyI18nRuntimeOverrides(base, shipped.value, silent) : base;
+    return domains && shipped.value?.domain ? configForHost(config2, shipped.value.domain) : config2;
+  }
+  const config = applyI18nRuntimeOverrides(base, readI18nRuntimeOverrides(nuxtApp.$config.public));
+  return domains ? configForHost(config, location.host) : config;
+}
+export function useResolvedI18nConfig(nuxtApp) {
+  let config = configs.get(nuxtApp);
+  if (!config) configs.set(nuxtApp, config = resolve(nuxtApp));
+  return config;
+}

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

@@ -0,0 +1,26 @@
+import type { PathStrategy } from '@i18n-micro/path-strategy';
+import type { ResolvedI18nConfig } from '@i18n-micro/types';
+import type { Router } from 'vue-router';
+import type { NuxtApp } from 'nuxt/app';
+import type { useI18nLocale } from '../composables/useI18nLocale.js';
+import type { NuxtI18nPluginApi } from './i18n-api.js';
+import type { NuxtI18n, NuxtTranslationLoader } from './nuxt-i18n.js';
+export interface I18nNavigationDeps {
+    nuxtApp: NuxtApp;
+    router: Router;
+    i18n: NuxtI18n;
+    loader: NuxtTranslationLoader;
+    i18nConfig: ResolvedI18nConfig;
+    i18nStrategy: PathStrategy;
+    locale: ReturnType<typeof useI18nLocale>;
+    api: NuxtI18nPluginApi;
+    /** The page changed: what the last one set for itself (route params, head) goes. */
+    leavePage: () => void;
+}
+/**
+ * Translations follow navigations: a guard loads what the target shows, and it is applied when the navigation commits.
+ * A guard is too early: a later guard can abort, and the router cancels a pending navigation for a duplicate of the
+ * current page without running one.
+ * ponytail: a file of its own, like `i18n-api`, keeps the plugin a flat list of steps for about 300 B gzip of property names. Inline them if a bundle budget needs it.
+ */
+export declare function setupI18nNavigation(deps: I18nNavigationDeps): void;

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

@@ -0,0 +1,96 @@
+import { hooks } from "#build/i18n.strategy.mjs";
+function createOutgoingWatch(nuxtApp, i18n) {
+  let stopWaiting;
+  let noElement = null;
+  nuxtApp.hook("page:finish", () => {
+    i18n.finishTransition(noElement);
+    noElement = null;
+  });
+  return (page) => {
+    stopWaiting?.();
+    noElement = null;
+    const outgoing = i18n.outgoing;
+    const element = page?.$el;
+    if (!element?.isConnected) {
+      noElement = outgoing;
+      return;
+    }
+    if (!outgoing) return;
+    const observer = new MutationObserver(() => {
+      if (element.isConnected) return;
+      stopWaiting?.();
+      i18n.finishTransition(outgoing);
+    });
+    observer.observe(document, { childList: true, subtree: true });
+    stopWaiting = () => {
+      observer.disconnect();
+      stopWaiting = void 0;
+    };
+  };
+}
+function createRegister(nuxtApp, { mergeTranslation }) {
+  const subscribed = () => {
+    const { _hooks: subscribers } = nuxtApp.hooks;
+    return !subscribers || Boolean(subscribers["i18n:register"]?.length);
+  };
+  return async (locale, routeName) => {
+    if (!subscribed()) return;
+    const merges = [];
+    const register = (translations, selectedLocale) => {
+      merges.push(mergeTranslation(selectedLocale ?? locale, routeName, translations));
+    };
+    await nuxtApp.callHook("i18n:register", register, locale);
+    await Promise.all(merges);
+  };
+}
+export function setupI18nNavigation(deps) {
+  const { nuxtApp, router, i18n, loader, i18nConfig, i18nStrategy, api, leavePage } = deps;
+  const noPrefix = i18nConfig.strategy === "no_prefix";
+  const { locale: localeState, getPreferredLocale, isValidLocale, setLocale } = deps.locale;
+  const finishWhenGone = createOutgoingWatch(nuxtApp, i18n);
+  const register = createRegister(nuxtApp, api.helper);
+  const targets = /* @__PURE__ */ new WeakMap();
+  if (hooks) nuxtApp.hooks.hookOnce("app:created", () => register(i18n.getLocale(), i18n.getCurrentRouteName()));
+  const loadTarget = async (to) => {
+    try {
+      const hashLocale = i18nConfig.hashMode ? i18nStrategy.getLocaleFromPath(to.path) : null;
+      const locale = hashLocale || api.provide.getLocale(to);
+      const routeName = i18nStrategy.getPluginRouteName(to, locale);
+      const changed = locale !== i18n.getLocale() || routeName !== i18n.getCurrentRouteName();
+      return { locale, routeName, changed, data: changed ? await loader.fetchContext(locale, routeName) : null };
+    } catch (e) {
+      if (process.env.NODE_ENV !== "production") console.error("[i18n] Navigation error:", e);
+      return void 0;
+    }
+  };
+  router.beforeEach(async (to, from) => {
+    if (to.path === from.path && !noPrefix) return;
+    const paths = noPrefix ? to.matched.at(-1)?.meta.i18n?.paths : void 0;
+    const customPath = paths?.[api.provide.getLocale(to)];
+    if (customPath) return { path: customPath, query: to.query, hash: to.hash };
+    loader.invalidatePendingSwitches();
+    const target = await loadTarget(to);
+    if (!target) return;
+    targets.set(to, target);
+    if (hooks) await register(target.locale, target.routeName);
+  });
+  router.afterEach((to, from, failure) => {
+    if (failure) return;
+    if (to.path !== from.path) leavePage();
+    const target = targets.get(to);
+    if (!target) return;
+    const { locale, routeName, changed, data } = target;
+    const applied = !changed || loader.applyContext(locale, routeName, data && (loader.loadFromCacheSync(locale, routeName) ?? data));
+    const left = from.matched.at(-1);
+    const stays = from.matched.some((record) => record.path === left?.path && to.matched.includes(record));
+    if (changed && applied && !stays) finishWhenGone(left?.instances.default);
+    const bound = noPrefix && locale !== (getPreferredLocale() ?? i18nConfig.defaultLocale);
+    if (!applied || bound || !locale || !isValidLocale(locale)) return;
+    if (!to.matched.length) {
+      localeState.value = locale;
+      return;
+    }
+    const urlNamed = !noPrefix && !i18nConfig.hashMode && import.meta.client && !nuxtApp.isHydrating;
+    if (urlNamed || localeState.value !== locale) setLocale(locale);
+  });
+}

package/dist/runtime/utils/nuxt-i18n-server.d.ts

@@ -0,0 +1,26 @@
+import type { TranslationKey, Translations } from '@i18n-micro/types';
+import { NuxtI18n } from './nuxt-i18n.js';
+type Tree = Record<string, unknown>;
+/**
+ * The instance of a server request. Its chunks are the process's shared trees, and a patch (`i18n:register`,
+ * `$mergeTranslations`) is this request's alone: merging would copy the root of a shared tree on every request, and a new
+ * tree starts with a cold leaf cache. So a patch stays beside its chunk, and a lookup reads through it. A subscriber may
+ * register other keys per request: nothing is shared or cached between requests but the chunk, which no one writes to.
+ * ponytail: what needs the whole tree (`$resolveTranslations`, `$setTranslation`) merges once, at O(chunk) for that request.
+ */
+export declare class ServerNuxtI18n extends NuxtI18n {
+    /** Patches of the dictionary on screen, not merged yet, in order. A chunk off screen is read by no one here: it merges at once. */
+    private overlay;
+    private keyOnScreen;
+    /** The merge the patches stood in for, once a caller needs the tree. */
+    private settle;
+    getChunk(locale: string, routeName?: string): Tree;
+    protected patch(locale: string, routeName: string, translations: Translations): void;
+    protected resolveLookup(key: TranslationKey, routeContext?: unknown): unknown | null;
+    applySwitchContext(locale: string, routeName: string | undefined, data: Tree | null): void;
+    resolveTranslations(routeContext?: unknown): Translations;
+    setTranslation(key: TranslationKey, value: unknown): void;
+    dropChunks(): void;
+    clearCache(): void;
+}
+export {};

package/dist/runtime/utils/nuxt-i18n-server.js

@@ -0,0 +1,83 @@
+import { mergeTranslationChunk } from "@i18n-micro/core";
+import { NuxtI18n } from "./nuxt-i18n.js";
+const isTree = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function nodesAt(layers, key) {
+  const trees = [];
+  for (let index = layers.length - 1; index >= 0; index--) {
+    const layer = layers[index];
+    if (!Object.hasOwn(layer, key)) continue;
+    const value = layer[key];
+    if (!isTree(value)) return trees.length ? trees : [value];
+    trees.unshift(value);
+  }
+  return trees;
+}
+const valueOf = (nodes) => nodes.length < 2 ? nodes[0] : nodes.reduce((merged, node) => mergeTranslationChunk(merged, node));
+function resolveLayered(layers, key) {
+  const flat = valueOf(nodesAt(layers, key));
+  if (flat !== void 0 && flat !== null || key.indexOf(".") === -1) return flat ?? null;
+  let nodes = layers;
+  for (const part of key.split(".")) {
+    const node = nodes[0];
+    if (node === null || typeof node !== "object" || part === "__proto__" || part === "length" && Array.isArray(node)) return null;
+    nodes = nodesAt(nodes, part);
+  }
+  return valueOf(nodes) ?? null;
+}
+function touches(fragments, key) {
+  const dot = key.indexOf(".");
+  const head = dot === -1 ? key : key.slice(0, dot);
+  return fragments.some((fragment) => Object.hasOwn(fragment, key) || Object.hasOwn(fragment, head));
+}
+export class ServerNuxtI18n extends NuxtI18n {
+  /** Patches of the dictionary on screen, not merged yet, in order. A chunk off screen is read by no one here: it merges at once. */
+  overlay;
+  keyOnScreen() {
+    return this.getCacheKey(this.getLocale(), this.getCurrentRouteName());
+  }
+  /** The merge the patches stood in for, once a caller needs the tree. */
+  settle() {
+    if (!this.overlay) return;
+    const merged = this.overlay.reduce((tree, fragment) => mergeTranslationChunk(tree, fragment), this.cachedTranslations);
+    this.overlay = void 0;
+    this.cachedTranslations = merged;
+    this.storePatched(this.keyOnScreen(), merged);
+  }
+  getChunk(locale, routeName) {
+    if (this.overlay && this.getCacheKey(locale, routeName) === this.keyOnScreen()) this.settle();
+    return super.getChunk(locale, routeName);
+  }
+  patch(locale, routeName, translations) {
+    const active = locale === this.getLocale() && (routeName || "index") === this.getRoute();
+    if (!active || this.storage.translations.get(this.keyOnScreen()) !== this.cachedTranslations) return super.patch(locale, routeName, translations);
+    (this.overlay ??= []).push(mergeTranslationChunk({}, translations));
+    this.notifyLoaded();
+  }
+  resolveLookup(key, routeContext) {
+    if (!this.overlay) return super.resolveLookup(key, routeContext);
+    const text = String(key);
+    const chunkKey = routeContext ? this.chunkKeyOf(routeContext) : void 0;
+    if (chunkKey !== void 0 && chunkKey !== this.keyOnScreen() || !touches(this.overlay, text)) return super.resolveLookup(key, routeContext);
+    return resolveLayered([this.cachedTranslations, ...this.overlay], text);
+  }
+  applySwitchContext(locale, routeName, data) {
+    this.settle();
+    super.applySwitchContext(locale, routeName, data);
+  }
+  resolveTranslations(routeContext) {
+    this.settle();
+    return super.resolveTranslations(routeContext);
+  }
+  setTranslation(key, value) {
+    this.settle();
+    super.setTranslation(key, value);
+  }
+  dropChunks() {
+    this.settle();
+    super.dropChunks();
+  }
+  clearCache() {
+    this.overlay = void 0;
+    super.clearCache();
+  }
+}

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

@@ -1,8 +1,6 @@
-import { BaseI18n, type BaseI18nOptions, type TranslationStorage } from '@i18n-micro/core';
-import type { PathStrategy, ResolvedRouteLike } from '@i18n-micro/path-strategy';
-import type { CleanTranslation, I18nRouteParams, MissingHandler, ModuleOptionsExtend, Params, TranslationKey, Translations } from '@i18n-micro/types';
-import type { RouteLocationNamedRaw, RouteLocationNormalizedLoaded, RouteLocationRaw, RouteLocationResolved, RouteLocationResolvedGeneric, Router } from 'vue-router';
-import type { GetLocaleFromRoute } from '../composables/useI18nLocale.js';
+import { BaseI18n, FormatService, type BaseI18nOptions, type TranslationStorage } from '@i18n-micro/core';
+import type { CleanTranslation, ResolvedI18nConfig, Params, TranslationKey, Translations } from '@i18n-micro/types';
+import { type ShallowRef } from 'vue';
 import { type LoadOptions } from './storage.js';
 export type TranslationFn<T extends CleanTranslation> = (key: TranslationKey, params?: Params, defaultValue?: string | null) => T;
 export interface RouteTranslationContext {
@@ -21,11 +19,17 @@ export interface NuxtI18nOptions extends BaseI18nOptions {
      */
     cacheMaxSize?: number;
 }
+/**
+ * The server's formatters. `Intl` objects are costly and depend only on what the service is built
+ * from, so requests share them: its input is this read-only config, and no request reaches it
+ * (`$tn` and `$td` pass the locale per call). One per resolved config: runtime overrides and hosts.
+ */
+export declare function formatterFor(config: ResolvedI18nConfig): FormatService;
 export declare class NuxtI18n extends BaseI18n {
     readonly storage: TranslationStorage;
     private readonly cacheMaxSize;
-    private readonly contextSignal;
-    private cachedTranslations;
+    protected readonly contextSignal: ShallowRef<number>;
+    protected cachedTranslations: Record<string, unknown>;
     /**
      * Hot-reload buffer for page transitions: the leaving page's chunk, kept until it unmounts.
      *
@@ -33,6 +37,10 @@ export declare class NuxtI18n extends BaseI18n {
      * already installed. Cleared in `finishTransition`.
      */
     private outgoingTranslations;
+    /** A lookup was answered from `outgoingTranslations`: only then does dropping it change a render. */
+    private outgoingServed;
+    /** Chunks that hold only what was patched in: no page's file has reached them, so to a loader they are not loaded. */
+    private readonly fragments;
     private currentLocale;
     private currentRouteName;
     private resolveRouteContext?;
@@ -42,19 +50,16 @@ export declare class NuxtI18n extends BaseI18n {
     setRouteContextResolver(resolver: GetRouteTranslationContext): void;
     getCacheKey(locale: string, routeName?: string): string;
     getChunk(locale: string, routeName?: string): Record<string, unknown>;
-    setChunk(locale: string, routeName: string | undefined, data: Record<string, unknown>): void;
+    /** The chunk is loaded. What a patch alone stored is a fragment, see `installChunk`. */
+    hasChunk(locale: string, routeName?: string): boolean;
     /**
-     * Install SSR chunks from the payload into the view layer.
-     *
-     * The loader only installs the chunk for the page being rendered, but SSR may
-     * load buckets for other `(locale, route)` pairs — `$tForRoute()` resolves against
-     * `getChunk()` directly. Without this they hydrate as missing until navigation.
-     *
-     * Existing entries win: anything already loaded is kept as-is.
+     * A chunk fresh from a load or the cache, under what was patched in before it came: patches win. Without any, it
+     * is stored as it is: a stored tree is never written to, so it needs no copy.
      */
-    seedChunks(chunks: Record<string, Record<string, unknown>>): void;
-    hasChunk(locale: string, routeName?: string): boolean;
+    installChunk(locale: string, routeName: string | undefined, data: Record<string, unknown>): Record<string, unknown>;
     mergeChunk(locale: string, routeName: string | undefined, data: Record<string, unknown>): Record<string, unknown>;
+    /** A tree a patch made: over no loaded chunk (a stand-in, an evicted one) it is a fragment, and the next visit still loads. */
+    protected storePatched(key: string, tree: Record<string, unknown>): void;
     /**
      * FIFO eviction for `storage.translations` when `cacheMaxSize` is set.
      * Prefers keeping the just-written key and the active page chunk. When those
@@ -66,7 +71,6 @@ export declare class NuxtI18n extends BaseI18n {
     getLocale(): string;
     getFallbackLocale(): string;
     getRoute(): string;
-    getCurrentLocale(): string;
     getCurrentRouteName(): string;
     onContextChange(listener: (reason: I18nContextChangeReason) => void): () => void;
     onMissingKey(listener: (locale: string, key: string, routeName: string) => void): () => void;
@@ -81,17 +85,33 @@ export declare class NuxtI18n extends BaseI18n {
      * a shallow merge loses nested keys. Two plain objects + fallthrough on miss is cheaper
      * and correct for the short hot-reload window.
      */
-    applySwitchContext(locale: string, routeName: string | undefined, data: Record<string, unknown>): void;
-    /** The outgoing page has unmounted, so its keys must stop resolving. */
-    finishTransition(): void;
+    applySwitchContext(locale: string, routeName: string | undefined, data: Record<string, unknown> | null): void;
+    /**
+     * Swap the active dictionary for a fresh copy of the same page. Not a page change: a live
+     * transition keeps its outgoing layer, the leaving page is still on screen.
+     */
+    replaceDictionary(data: Record<string, unknown>): void;
+    /** The leaving page's chunk while it may still render, or null. */
+    get outgoing(): Record<string, unknown> | null;
+    /**
+     * The outgoing page has unmounted, so its keys must stop resolving. `outgoing` names which
+     * page left: a transition that ends after the next navigation must not drop that one's chunk.
+     */
+    finishTransition(outgoing?: Record<string, unknown> | null): void;
+    /** Merge a fragment into a chunk and, when that chunk is on screen, into the active dictionary. */
+    protected patch(locale: string, routeName: string, translations: Translations): void;
+    /** The active dictionary changed: what rendered from it renders again. */
+    protected notifyLoaded(): void;
     mergeTranslations(newTranslations: Translations): void;
     loadPageTranslations(locale: string, routeName: string, translations: Translations): Promise<void>;
     mergeTranslationAsync(locale: string, routeName: string, newTranslations: Translations, loadIfMissing: LoadTranslationsChunk): Promise<void>;
     tForRoute(route: unknown): TranslationFn<CleanTranslation>;
     tsForRoute(route: unknown): TranslationFn<string>;
     protected touch(): void;
+    /** The chunk a route reads from, when routes are known here. */
+    protected chunkKeyOf(routeContext: unknown): string | undefined;
     protected resolveLookup(key: TranslationKey, routeContext?: unknown): unknown | null;
-    protected resolveHas(key: TranslationKey): boolean;
+    protected resolveHas(key: TranslationKey, routeContext?: unknown): boolean;
     /**
      * Dump what `$t` can resolve right now — including the hot-reload buffer while a transition
      * is in flight. Outside that window this is just `cachedTranslations`.
@@ -110,100 +130,65 @@ export declare class NuxtI18n extends BaseI18n {
         routeName: string;
     };
     protected warnMissing(key: TranslationKey, routeContext?: unknown): void;
+    /** Drop every stored chunk but keep the dictionary on screen until a reload replaces it. */
+    dropChunks(): void;
     clearCache(): void;
 }
 export interface NuxtTranslationLoaderOptions {
     i18n: NuxtI18n;
     loadOptions: LoadOptions;
-    isDev?: boolean;
+    /** The render is a file: a first page with no dictionary fails, as raw keys would stay in it. */
+    prerender?: boolean;
+    /** Any chunk of this render failed to load, the first page's or one merged later. A 404 is no failure. */
+    onFailedRead?: () => void;
 }
 export declare class NuxtTranslationLoader {
     private readonly options;
     private readonly pendingLoads;
     /**
-     * Monotonic token so a slower in-flight `switchContext` cannot overwrite a newer one.
-     * Vue Router aborts a superseded navigation but does not cancel the guard's await.
+     * Monotonic token so a slower in-flight `switchContext` (`$switchLocale` without a URL to move)
+     * cannot overwrite a newer one. Navigations do not need it: they apply when they commit.
      */
     private switchGeneration;
     constructor(options: NuxtTranslationLoaderOptions);
     /**
      * Bump the switch generation so any in-flight `switchContext` becomes a no-op.
-     * Call on every navigation that may supersede a pending load — including when the
-     * target `(locale, routeName)` already matches the applied context (caller skips switch).
+     * Call on every navigation that may supersede a pending load.
      */
     invalidatePendingSwitches(): void;
     loadFromCacheSync(locale: string, routeName?: string): Record<string, unknown> | null;
+    /** The chunk, or `{}` when the load fails (a page without translations still renders). */
     loadAsync(locale: string, routeName?: string): Promise<Record<string, unknown>>;
+    /** The loaded chunk, or null when the load failed (reported here): a reload must tell that from an empty chunk. */
+    private loadChunk;
     /**
-     * Load and apply translations for a locale/route. Returns `false` when a newer
-     * navigation superseded this switch — callers must skip post-await side effects
-     * (e.g. `setLocale`) for the abandoned navigation.
+     * Reload the current context's dictionary (after a cache clear, an HMR edit). Unlike
+     * {@link switchContext} it does not supersede an in-flight navigation: the fresh chunk is
+     * applied only if the context is still the one it was loaded for.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Drop every cached chunk (storage and instance) and reload the current page's dictionary.
+     * The page keeps its current dictionary until the fresh one is applied: no raw keys between.
+     */
+    reload(): Promise<void>;
+    /** The chunk of a context, cached or loaded, or null when its load failed. */
+    fetchContext(locale: string, routeName?: string): Record<string, unknown> | Promise<Record<string, unknown> | null>;
+    /**
+     * Make a fetched chunk the active context. `false` when its load failed: that keeps what is on screen, as
+     * refresh() does, since an empty dictionary would turn the strings that still work (a layout's) into raw keys.
+     * Only a first render has nothing to keep. A prerender throws there instead: no next request would load it again.
+     */
+    applyContext(locale: string, routeName: string | undefined, data: Record<string, unknown> | null): boolean;
+    /**
+     * Load and apply translations for a locale/route. Returns `false` when the switch did not
+     * apply — a newer navigation superseded it, or its chunk failed to load — and callers must
+     * skip post-await side effects (e.g. `setLocale`). The next navigation loads it again.
      */
     switchContext(locale: string, routeName?: string): Promise<boolean>;
+    /**
+     * A first render whose chunk failed has nothing to keep, but its root dictionary can be at hand (the shared
+     * cache in a host outage): the layout's strings stay text. A prerender must fail instead, it would keep the file.
+     */
+    private firstRenderStandIn;
 }
-export interface NuxtI18nPluginApiDeps {
-    i18n: NuxtI18n;
-    loader: NuxtTranslationLoader;
-    i18nStrategy: PathStrategy;
-    i18nConfig: ModuleOptionsExtend;
-    router: Router;
-    getCurrentLocale: (route?: ResolvedRouteLike) => string;
-    getEffectiveLocale: (route: unknown, getLocaleFromRoute: GetLocaleFromRoute) => string;
-    getPluginRouteName: (route: ResolvedRouteLike, locale: string) => string;
-    getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, locale?: string) => string;
-    i18nRouteParams: {
-        value: I18nRouteParams;
-    };
-    setLocale: (locale: string) => void;
-    isValidLocale: (locale: string) => boolean;
-    navigateTo: (to: string, options?: {
-        redirectCode?: number;
-        external?: boolean;
-    }) => unknown;
-    setMissingHandler: (handler: MissingHandler | null) => void;
-}
-export declare function createNuxtI18nPluginApi(deps: NuxtI18nPluginApiDeps): {
-    helper: {
-        mergeTranslation(locale: string, routeName: string, newTranslations: Translations, _force?: boolean): Promise<void>;
-    };
-    switchContext: (locale: string, routeName?: string) => Promise<boolean>;
-    provide: {
-        i18nStrategy: PathStrategy;
-        getLocale: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => string;
-        getLocaleName: () => string | null;
-        defaultLocale: () => string | undefined;
-        getLocales: () => import("@i18n-micro/types").Locale[];
-        getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, locale?: string) => string;
-        t: (key: TranslationKey, params?: Params, defaultValue?: string | null, routeContext?: unknown) => CleanTranslation;
-        ts: (key: TranslationKey, params?: Params, defaultValue?: string, route?: RouteLocationNormalizedLoaded) => string;
-        _t: (route: RouteLocationNormalizedLoaded) => TranslationFn<CleanTranslation>;
-        _ts: (route: RouteLocationNormalizedLoaded) => TranslationFn<string>;
-        tc: (key: TranslationKey, count: number | Params, defaultValue?: string) => 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: TranslationKey, routeContext?: unknown) => boolean;
-        resolveTranslations: (routeContext?: unknown) => Translations;
-        setTranslation: (key: TranslationKey, value: unknown) => void;
-        mergeTranslations: (newTranslations: Translations) => void;
-        switchLocaleRoute: (toLocale: string) => RouteLocationRaw;
-        clearCache: () => void;
-        switchLocalePath: (toLocale: string) => string;
-        switchLocale: (toLocale: string) => Promise<unknown>;
-        switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => 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 NuxtI18nPluginProvide = ReturnType<typeof createNuxtI18nPluginApi>['provide'];