nuxt-i18n-micro 3.30.3 → 4.0.0

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

@@ -1,35 +1,19 @@
 import {
   BaseI18n,
-  isNoPrefixStrategy,
+  FormatService,
   mergeTranslationChunk,
-  resolveTranslation,
+  resolveCachedTranslation,
   setTranslationAtKey,
   translationCacheKey
 } from "@i18n-micro/core";
-import { deepMergeTranslationsRecursive } from "@i18n-micro/utils/deep-merge";
-import { shallowRef, triggerRef, unref } from "vue";
+import { PREMERGED_ROOT_PAGE } from "@i18n-micro/utils/merge-source";
+import { shallowRef, triggerRef } from "vue";
 import { translationStorage } from "./storage.js";
-import { applyTrailingSlash } from "./trailing-slash.js";
-function toRouteLocationResolved(result) {
-  const fullPath = result.fullPath ?? result.path ?? "";
-  const path = result.path ?? fullPath.split("?")[0]?.split("#")[0] ?? fullPath;
-  const out = {
-    path,
-    fullPath,
-    href: fullPath
-  };
-  if (result.query && Object.keys(result.query).length) out.query = result.query;
-  if (result.hash) out.hash = result.hash;
-  return out;
-}
-function extractSwitchLocalePath(localeRoute, resolveRouter) {
-  if (!localeRoute || typeof localeRoute !== "object") return String(localeRoute ?? "");
-  if ("fullPath" in localeRoute && localeRoute.fullPath) return localeRoute.fullPath;
-  if ("path" in localeRoute && localeRoute.path) return localeRoute.path;
-  if ("name" in localeRoute && localeRoute.name && resolveRouter.hasRoute(String(localeRoute.name))) {
-    return resolveRouter.resolve(localeRoute).fullPath;
-  }
-  return "";
+const formatters = /* @__PURE__ */ new WeakMap();
+export function formatterFor(config) {
+  let formatter = formatters.get(config);
+  if (!formatter) formatters.set(config, formatter = new FormatService(config));
+  return formatter;
 }
 export class NuxtI18n extends BaseI18n {
   storage;
@@ -43,6 +27,10 @@ export class NuxtI18n extends BaseI18n {
    * already installed. Cleared in `finishTransition`.
    */
   outgoingTranslations = null;
+  /** A lookup was answered from `outgoingTranslations`: only then does dropping it change a render. */
+  outgoingServed = false;
+  /** Chunks that hold only what was patched in: no page's file has reached them, so to a loader they are not loaded. */
+  fragments = /* @__PURE__ */ new Set();
   currentLocale = "";
   currentRouteName = "";
   resolveRouteContext;
@@ -67,41 +55,35 @@ export class NuxtI18n extends BaseI18n {
   getChunk(locale, routeName) {
     return this.storage.translations.get(this.getCacheKey(locale, routeName)) ?? {};
   }
-  setChunk(locale, routeName, data) {
+  /** The chunk is loaded. What a patch alone stored is a fragment, see `installChunk`. */
+  hasChunk(locale, routeName) {
     const key = this.getCacheKey(locale, routeName);
-    this.storage.translations.set(key, data);
-    this.evictChunks(key);
+    return this.storage.translations.has(key) && !this.fragments.has(key);
   }
   /**
-   * 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) {
-    let lastKey = "";
-    for (const [cacheKey, data] of Object.entries(chunks)) {
-      if (!this.storage.translations.has(cacheKey)) {
-        this.storage.translations.set(cacheKey, data);
-        lastKey = cacheKey;
-      }
-    }
-    if (lastKey) this.evictChunks(lastKey);
-  }
-  hasChunk(locale, routeName) {
-    return this.storage.translations.has(this.getCacheKey(locale, routeName));
+  installChunk(locale, routeName, data) {
+    const existing = this.getChunk(locale, routeName);
+    const chunk = Object.keys(existing).length ? mergeTranslationChunk(existing, data, { preserveExisting: true }) : data;
+    const key = this.getCacheKey(locale, routeName);
+    this.storage.translations.set(key, chunk);
+    this.fragments.delete(key);
+    this.evictChunks(key);
+    return chunk;
   }
   mergeChunk(locale, routeName, data) {
-    const cacheKey = this.getCacheKey(locale, routeName);
-    const existing = this.storage.translations.get(cacheKey) ?? {};
-    const merged = mergeTranslationChunk(existing, data);
-    this.storage.translations.set(cacheKey, merged);
-    this.evictChunks(cacheKey);
+    const merged = mergeTranslationChunk(this.getChunk(locale, routeName), data);
+    this.storePatched(this.getCacheKey(locale, routeName), merged);
     return merged;
   }
+  /** 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. */
+  storePatched(key, tree) {
+    if (!this.storage.translations.has(key)) this.fragments.add(key);
+    this.storage.translations.set(key, tree);
+    this.evictChunks(key);
+  }
   /**
    * FIFO eviction for `storage.translations` when `cacheMaxSize` is set.
    * Prefers keeping the just-written key and the active page chunk. When those
@@ -112,17 +94,13 @@ export class NuxtI18n extends BaseI18n {
   evictChunks(keep) {
     const max = this.cacheMaxSize;
     if (max <= 0 || this.storage.translations.size <= max) return;
+    const { translations } = this.storage;
     const current = this.getCacheKey(this.currentLocale, this.currentRouteName);
-    for (const key of this.storage.translations.keys()) {
-      if (this.storage.translations.size <= max) break;
-      if (key === keep || key === current) continue;
-      this.storage.translations.delete(key);
-    }
-    if (this.storage.translations.size <= max) return;
-    for (const key of this.storage.translations.keys()) {
-      if (this.storage.translations.size <= max) break;
-      if (key === keep) continue;
-      this.storage.translations.delete(key);
+    const victims = [...translations.keys()].filter((key) => key !== keep && key !== current);
+    if (current !== keep) victims.push(current);
+    for (const key of victims) {
+      if (translations.size <= max) return;
+      translations.delete(key);
     }
   }
   getLocale() {
@@ -134,9 +112,6 @@ export class NuxtI18n extends BaseI18n {
   getRoute() {
     return this.currentRouteName || "index";
   }
-  getCurrentLocale() {
-    return this.currentLocale;
-  }
   getCurrentRouteName() {
     return this.currentRouteName;
   }
@@ -155,8 +130,13 @@ export class NuxtI18n extends BaseI18n {
     };
   }
   notifyContextChange(reason) {
-    for (const listener of this.contextListeners) {
-      listener(reason);
+    for (const listener of [...this.contextListeners]) {
+      if (!this.contextListeners.has(listener)) continue;
+      try {
+        listener(reason);
+      } catch (error) {
+        console.error("[i18n] context listener failed:", error);
+      }
     }
   }
   /**
@@ -171,45 +151,61 @@ export class NuxtI18n extends BaseI18n {
    */
   applySwitchContext(locale, routeName, data) {
     this.outgoingTranslations = this.currentLocale === locale ? this.cachedTranslations : null;
-    this.cachedTranslations = data;
+    this.outgoingServed = false;
+    this.cachedTranslations = data ?? {};
     this.currentLocale = locale;
     this.currentRouteName = routeName || "";
-    this.setChunk(locale, routeName, data);
-    triggerRef(this.contextSignal);
-    this.notifyContextChange("load");
+    this.notifyLoaded();
+  }
+  /**
+   * 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) {
+    this.cachedTranslations = data;
+    this.notifyLoaded();
+    this.notifyContextChange("refresh");
+  }
+  /** The leaving page's chunk while it may still render, or null. */
+  get outgoing() {
+    return this.outgoingTranslations;
   }
-  /** The outgoing page has unmounted, so its keys must stop resolving. */
-  finishTransition() {
-    if (this.outgoingTranslations === null) return;
+  /**
+   * 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 = this.outgoingTranslations) {
+    if (outgoing === null || outgoing !== this.outgoingTranslations) return;
     this.outgoingTranslations = null;
-    triggerRef(this.contextSignal);
+    if (this.outgoingServed) triggerRef(this.contextSignal);
     this.notifyContextChange("refresh");
   }
-  mergeTranslations(newTranslations) {
-    this.mergeChunk(this.currentLocale, this.currentRouteName, newTranslations);
-    this.cachedTranslations = deepMergeTranslationsRecursive(this.cachedTranslations, newTranslations);
+  /** Merge a fragment into a chunk and, when that chunk is on screen, into the active dictionary. */
+  patch(locale, routeName, translations) {
+    const stored = this.storage.translations.get(this.getCacheKey(locale, routeName));
+    const merged = this.mergeChunk(locale, routeName, translations);
+    if (locale !== this.currentLocale || (routeName || "index") !== this.getRoute()) return;
+    const onScreen = this.cachedTranslations;
+    this.cachedTranslations = stored === onScreen ? merged : mergeTranslationChunk(onScreen, translations);
+    this.notifyLoaded();
+  }
+  /** The active dictionary changed: what rendered from it renders again. */
+  notifyLoaded() {
     triggerRef(this.contextSignal);
     this.notifyContextChange("load");
   }
+  mergeTranslations(newTranslations) {
+    this.patch(this.currentLocale, this.currentRouteName, newTranslations);
+  }
   async loadPageTranslations(locale, routeName, translations) {
-    this.mergeChunk(locale, routeName, translations);
-    if (locale === this.currentLocale && routeName === this.currentRouteName) {
-      this.cachedTranslations = deepMergeTranslationsRecursive(this.cachedTranslations, translations);
-      triggerRef(this.contextSignal);
-      this.notifyContextChange("load");
-    }
+    this.patch(locale, routeName, translations);
   }
   async mergeTranslationAsync(locale, routeName, newTranslations, loadIfMissing) {
     if (!this.hasChunk(locale, routeName)) {
       const loaded = await loadIfMissing(locale, routeName || void 0);
-      this.setChunk(locale, routeName, loaded);
-    }
-    this.mergeChunk(locale, routeName, newTranslations);
-    if (locale === this.currentLocale && routeName === this.currentRouteName) {
-      this.cachedTranslations = deepMergeTranslationsRecursive(this.cachedTranslations, newTranslations);
-      triggerRef(this.contextSignal);
-      this.notifyContextChange("load");
+      if (!this.hasChunk(locale, routeName) && Object.keys(loaded).length) this.installChunk(locale, routeName, loaded);
     }
+    this.patch(locale, routeName, newTranslations);
   }
   tForRoute(route) {
     return (key, params, defaultValue) => this.t(key, params, defaultValue, route);
@@ -220,17 +216,24 @@ export class NuxtI18n extends BaseI18n {
   touch() {
     this.contextSignal.value;
   }
+  /** The chunk a route reads from, when routes are known here. */
+  chunkKeyOf(routeContext) {
+    if (!this.resolveRouteContext) return void 0;
+    const { locale, routeName } = this.resolveRouteContext(routeContext);
+    return this.getCacheKey(locale, routeName);
+  }
   resolveLookup(key, routeContext) {
-    const translations = routeContext && this.resolveRouteContext ? (() => {
-      const { locale, routeName } = this.resolveRouteContext(routeContext);
-      return this.getChunk(locale, routeName);
-    })() : this.cachedTranslations;
-    const value = resolveTranslation(translations, String(key));
+    const chunkKey = routeContext ? this.chunkKeyOf(routeContext) : void 0;
+    const translations = chunkKey === void 0 ? this.cachedTranslations : this.storage.translations.get(chunkKey) ?? {};
+    const value = resolveCachedTranslation(translations, String(key));
     if (value !== null || translations !== this.cachedTranslations) return value;
-    return this.outgoingTranslations === null ? null : resolveTranslation(this.outgoingTranslations, String(key));
+    if (this.outgoingTranslations === null) return null;
+    const leaving = resolveCachedTranslation(this.outgoingTranslations, String(key));
+    if (leaving !== null) this.outgoingServed = true;
+    return leaving;
   }
-  resolveHas(key) {
-    return this.resolveLookup(key) !== null;
+  resolveHas(key, routeContext) {
+    return this.resolveLookup(key, routeContext) !== null;
   }
   /**
    * Dump what `$t` can resolve right now — including the hot-reload buffer while a transition
@@ -243,6 +246,7 @@ export class NuxtI18n extends BaseI18n {
       return this.getChunk(locale, routeName);
     }
     if (this.outgoingTranslations === null) return this.cachedTranslations;
+    this.outgoingServed = true;
     return this.resolveTranslationTree(this.outgoingTranslations, this.cachedTranslations);
   }
   /**
@@ -254,11 +258,8 @@ export class NuxtI18n extends BaseI18n {
    */
   setTranslation(key, value) {
     this.cachedTranslations = setTranslationAtKey(this.cachedTranslations, String(key), value);
-    this.setChunk(
-      this.currentLocale,
-      this.currentRouteName,
-      setTranslationAtKey(this.getChunk(this.currentLocale, this.currentRouteName), String(key), value)
-    );
+    const chunk = this.getChunk(this.currentLocale, this.currentRouteName);
+    this.storePatched(this.getCacheKey(this.currentLocale, this.currentRouteName), setTranslationAtKey(chunk, String(key), value));
     triggerRef(this.contextSignal);
     this.notifyContextChange("refresh");
   }
@@ -280,7 +281,13 @@ export class NuxtI18n extends BaseI18n {
       console.warn(`[i18n] Missing key '${key}' in '${locale}' for route '${routeName}'`);
     }
   }
+  /** Drop every stored chunk but keep the dictionary on screen until a reload replaces it. */
+  dropChunks() {
+    this.fragments.clear();
+    super.clearCache();
+  }
   clearCache() {
+    this.fragments.clear();
     super.clearCache();
     this.cachedTranslations = {};
     this.outgoingTranslations = null;
@@ -294,14 +301,13 @@ export class NuxtTranslationLoader {
   }
   pendingLoads = /* @__PURE__ */ new Map();
   /**
-   * 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.
    */
   switchGeneration = 0;
   /**
    * 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() {
     this.switchGeneration++;
@@ -312,28 +318,26 @@ export class NuxtTranslationLoader {
       return i18n.getChunk(locale, routeName);
     }
     const cached = translationStorage.getFromCache(locale, routeName);
-    if (cached) {
-      i18n.setChunk(locale, routeName, cached.data);
-      return cached.data;
-    }
-    return null;
+    return cached && i18n.installChunk(locale, routeName, cached);
+  }
+  /** The chunk, or `{}` when the load fails (a page without translations still renders). */
+  async loadAsync(locale, routeName) {
+    return await this.loadChunk(locale, routeName) ?? {};
   }
-  loadAsync(locale, routeName) {
-    const { i18n, loadOptions, isDev } = this.options;
+  /** The loaded chunk, or null when the load failed (reported here): a reload must tell that from an empty chunk. */
+  loadChunk(locale, routeName) {
+    const { i18n, loadOptions } = this.options;
     const cacheKey = i18n.getCacheKey(locale, routeName);
     const pending = this.pendingLoads.get(cacheKey);
     if (pending) return pending;
     const promise = (async () => {
       try {
-        const result = await translationStorage.load(locale, routeName, loadOptions);
-        const existing = i18n.getChunk(locale, routeName);
-        const mergedChunk = mergeTranslationChunk(existing, result.data, { preserveExisting: true });
-        i18n.setChunk(locale, routeName, mergedChunk);
-        return mergedChunk;
+        return i18n.installChunk(locale, routeName, await translationStorage.load(locale, routeName, loadOptions));
       } catch (e) {
-        if (isDev) console.error("[i18n] Load error:", e);
+        if (process.env.NODE_ENV !== "production") console.error("[i18n] Load error:", e);
         else console.warn("[i18n] Translation load failed:", locale, routeName);
-        return {};
+        this.options.onFailedRead?.();
+        return null;
       } finally {
         this.pendingLoads.delete(cacheKey);
       }
@@ -342,138 +346,62 @@ export class NuxtTranslationLoader {
     return promise;
   }
   /**
-   * 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.
+   */
+  async refresh() {
+    const { i18n } = this.options;
+    const locale = i18n.getLocale();
+    const routeName = i18n.getCurrentRouteName() || void 0;
+    const data = await this.loadChunk(locale, routeName);
+    if (data === null) return;
+    if (i18n.getLocale() !== locale || (i18n.getCurrentRouteName() || void 0) !== routeName) return;
+    i18n.replaceDictionary(data);
+  }
+  /**
+   * 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.
+   */
+  async reload() {
+    translationStorage.clear();
+    this.options.i18n.dropChunks();
+    await this.refresh();
+  }
+  /** The chunk of a context, cached or loaded, or null when its load failed. */
+  fetchContext(locale, routeName) {
+    return this.loadFromCacheSync(locale, routeName) ?? this.loadChunk(locale, routeName);
+  }
+  /**
+   * 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, routeName, data) {
+    const { i18n, prerender } = this.options;
+    if (data === null && i18n.getLocale()) return false;
+    if (data === null && prerender) throw new Error(`[i18n] Translation load failed: ${locale} ${routeName}`);
+    i18n.applySwitchContext(locale, routeName, data);
+    return true;
+  }
+  /**
+   * 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.
    */
   async switchContext(locale, routeName) {
     const generation = ++this.switchGeneration;
-    let data = this.loadFromCacheSync(locale, routeName);
-    if (data === null) {
-      data = await this.loadAsync(locale, routeName);
-    }
-    if (generation !== this.switchGeneration) return false;
-    this.options.i18n.applySwitchContext(locale, routeName, data);
-    return true;
+    const data = await this.fetchContext(locale, routeName);
+    const shown = data ?? await this.firstRenderStandIn(locale, routeName);
+    return generation === this.switchGeneration && this.applyContext(locale, routeName, shown);
+  }
+  /**
+   * 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.
+   */
+  firstRenderStandIn(locale, routeName) {
+    const { i18n, prerender } = this.options;
+    if (prerender || i18n.getLocale() || routeName === PREMERGED_ROOT_PAGE) return null;
+    return this.fetchContext(locale, PREMERGED_ROOT_PAGE);
   }
-}
-export function createNuxtI18nPluginApi(deps) {
-  const {
-    i18n,
-    loader,
-    i18nStrategy,
-    i18nConfig,
-    router,
-    getCurrentLocale,
-    getEffectiveLocale,
-    getPluginRouteName,
-    getRouteName,
-    i18nRouteParams,
-    setLocale,
-    isValidLocale,
-    navigateTo,
-    setMissingHandler
-  } = deps;
-  const isDev = process.env.NODE_ENV !== "production";
-  const isNoPrefix = isNoPrefixStrategy(i18nConfig.strategy);
-  const switchLocaleLogic = (toLocale, i18nParams, to) => {
-    const fromLocale = getCurrentLocale();
-    const currentRoute = router.currentRoute.value;
-    let resolvedTarget;
-    if (typeof to === "string") {
-      resolvedTarget = router.resolve(i18nStrategy.formatPathForResolve(to, fromLocale, toLocale));
-    } else {
-      resolvedTarget = to ?? currentRoute;
-    }
-    const switchedRoute = i18nStrategy.switchLocaleRoute(fromLocale, toLocale, resolvedTarget, {
-      i18nRouteParams: i18nParams
-    });
-    if (typeof switchedRoute === "string" && (switchedRoute.startsWith("http://") || switchedRoute.startsWith("https://"))) {
-      return navigateTo(switchedRoute, { redirectCode: 200, external: true });
-    }
-    if (isNoPrefix) {
-      ;
-      switchedRoute.force = true;
-      return router.replace(switchedRoute);
-    }
-    return router.push(switchedRoute);
-  };
-  const helper = {
-    async mergeTranslation(locale, routeName, newTranslations, _force = false) {
-      await i18n.mergeTranslationAsync(locale, routeName, newTranslations, (l, r) => loader.loadAsync(l, r));
-    }
-  };
-  const switchContext = (locale, routeName) => loader.switchContext(locale, routeName);
-  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,
-    t: i18n.t.bind(i18n),
-    ts: (key, params, defaultValue, route) => {
-      const value = route ? i18n.t(key, params, defaultValue, route) : i18n.ts(key, params, defaultValue);
-      return value?.toString() ?? defaultValue ?? key;
-    },
-    _t: (route) => i18n.tForRoute(route),
-    _ts: (route) => i18n.tsForRoute(route),
-    tc: i18n.tc.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 route = router.currentRoute.value;
-      const fromLocale = getCurrentLocale(route);
-      return i18nStrategy.switchLocaleRoute(fromLocale, toLocale, route, { i18nRouteParams: unref(i18nRouteParams.value) });
-    },
-    clearCache: () => {
-      translationStorage.clear();
-      i18n.clearCache();
-    },
-    switchLocalePath: (toLocale) => {
-      const route = router.currentRoute.value;
-      const fromLocale = getCurrentLocale(route);
-      const switched = i18nStrategy.switchLocaleRoute(fromLocale, toLocale, route, { i18nRouteParams: unref(i18nRouteParams.value) });
-      return applyTrailingSlash(extractSwitchLocalePath(switched, router), i18nConfig.trailingSlash);
-    },
-    switchLocale: async (toLocale) => {
-      if (!isValidLocale(toLocale)) {
-        if (isDev) console.warn(`[i18n] Invalid locale '${toLocale}'`);
-        return;
-      }
-      if (isNoPrefixStrategy(i18nConfig.strategy) || i18nConfig.hashMode) {
-        const route = router.currentRoute.value;
-        const routeName = getPluginRouteName(route, toLocale);
-        const applied = await loader.switchContext(toLocale, routeName);
-        if (!applied) return;
-      }
-      setLocale(toLocale);
-      return switchLocaleLogic(toLocale, unref(i18nRouteParams.value));
-    },
-    switchRoute: (route, toLocale) => {
-      return switchLocaleLogic(toLocale ?? getCurrentLocale(), unref(i18nRouteParams.value), route);
-    },
-    localeRoute(to, locale) {
-      const targetLocale = locale !== void 0 && locale !== "" ? String(locale) : getCurrentLocale();
-      const result = i18nStrategy.localeRoute(targetLocale, to, router.currentRoute.value);
-      return toRouteLocationResolved(result);
-    },
-    localePath(to, locale) {
-      const targetLocale = locale !== void 0 && locale !== "" ? String(locale) : getCurrentLocale();
-      const result = i18nStrategy.localeRoute(targetLocale, to, router.currentRoute.value);
-      return applyTrailingSlash(result.fullPath ?? result.path ?? "", i18nConfig.trailingSlash);
-    },
-    setI18nRouteParams: (value) => {
-      i18nRouteParams.value = value;
-      return i18nRouteParams.value;
-    },
-    loadPageTranslations: i18n.loadPageTranslations.bind(i18n),
-    setMissingHandler
-  };
-  return { helper, switchContext, provide };
 }

package/dist/runtime/utils/page-head.d.ts

@@ -0,0 +1,12 @@
+import type { I18nHeadInput } from '@i18n-micro/types';
+/**
+ * The page's overrides. Out of `composables/`, which is auto-imported. The merge stays in `02.meta`:
+ * a page head set on the server only reaches the client in the payload, with no `useI18nHead` call there.
+ */
+export declare const usePageHead: () => import("vue").Ref<I18nHeadInput | null, I18nHeadInput | null>;
+/**
+ * The route of the page the caller lives in, which stays on that page while the next one loads: a route that differs
+ * from the router's means the page was left. Null outside a page (a `<RouterView>`): a layout or `app.vue` is never
+ * left, and its own `useRoute()` lags until `page:finish`, so that comparison would read every navigation as leaving.
+ */
+export declare const usePageRoute: () => import("vue-router").RouteLocationNormalizedLoadedGeneric | null;

package/dist/runtime/utils/page-head.js

@@ -0,0 +1,6 @@
+import { hasInjectionContext, inject } from "vue";
+import { viewDepthKey } from "vue-router";
+import { useRoute } from "#app/composables/router";
+import { useState } from "#app/composables/state";
+export const usePageHead = () => useState("i18n-head-page", () => null);
+export const usePageRoute = () => hasInjectionContext() && inject(viewDepthKey, 0) ? useRoute() : null;

package/dist/runtime/utils/request-url.d.ts

@@ -0,0 +1,6 @@
+import { type H3Event } from 'h3';
+/**
+ * `getRequestURL` for a pathname. It builds on `Host` and the request line, which a client writes: what does not parse must not
+ * cost the page. With a leading `/` any line is a path, so `GET http://[/` is a page that does not exist.
+ */
+export declare function requestURL(event: H3Event): URL;

package/dist/runtime/utils/request-url.js

@@ -0,0 +1,11 @@
+import { getRequestURL } from "h3";
+export function requestURL(event) {
+  try {
+    return getRequestURL(event);
+  } catch {
+    const path = event.path;
+    let start = 0;
+    while (path[start] === "/" || path[start] === "\\") start++;
+    return new URL(`/${path.slice(start)}`, "http://localhost");
+  }
+}