@depup/nuxt 4.2.2-depup.0

package/dist/app/composables/loading-indicator.js

@@ -0,0 +1,142 @@
+import { computed, getCurrentScope, onScopeDispose, shallowRef } from "vue";
+import { useNuxtApp } from "../nuxt.js";
+function defaultEstimatedProgress(duration, elapsed) {
+  const completionPercentage = elapsed / duration * 100;
+  return 2 / Math.PI * 100 * Math.atan(completionPercentage / 50);
+}
+function createLoadingIndicator(opts = {}) {
+  const { duration = 2e3, throttle = 200, hideDelay = 500, resetDelay = 400 } = opts;
+  const getProgress = opts.estimatedProgress || defaultEstimatedProgress;
+  const nuxtApp = useNuxtApp();
+  const progress = shallowRef(0);
+  const isLoading = shallowRef(false);
+  const error = shallowRef(false);
+  let done = false;
+  let rafId;
+  let throttleTimeout;
+  let hideTimeout;
+  let resetTimeout;
+  const start = (opts2 = {}) => {
+    _clearTimeouts();
+    error.value = false;
+    set(0, opts2);
+  };
+  function set(at = 0, opts2 = {}) {
+    if (nuxtApp.isHydrating) {
+      return;
+    }
+    if (at >= 100) {
+      return finish({ force: opts2.force });
+    }
+    clear();
+    progress.value = at < 0 ? 0 : at;
+    const throttleTime = opts2.force ? 0 : throttle;
+    if (throttleTime && import.meta.client) {
+      throttleTimeout = setTimeout(() => {
+        isLoading.value = true;
+        _startProgress();
+      }, throttleTime);
+    } else {
+      isLoading.value = true;
+      _startProgress();
+    }
+  }
+  function _hide() {
+    if (import.meta.client) {
+      hideTimeout = setTimeout(() => {
+        isLoading.value = false;
+        resetTimeout = setTimeout(() => {
+          progress.value = 0;
+        }, resetDelay);
+      }, hideDelay);
+    }
+  }
+  function finish(opts2 = {}) {
+    progress.value = 100;
+    done = true;
+    clear();
+    _clearTimeouts();
+    if (opts2.error) {
+      error.value = true;
+    }
+    if (opts2.force) {
+      progress.value = 0;
+      isLoading.value = false;
+    } else {
+      _hide();
+    }
+  }
+  function _clearTimeouts() {
+    if (import.meta.client) {
+      clearTimeout(hideTimeout);
+      clearTimeout(resetTimeout);
+    }
+  }
+  function clear() {
+    if (import.meta.client) {
+      clearTimeout(throttleTimeout);
+      cancelAnimationFrame(rafId);
+    }
+  }
+  function _startProgress() {
+    done = false;
+    let startTimeStamp;
+    function step(timeStamp) {
+      if (done) {
+        return;
+      }
+      startTimeStamp ??= timeStamp;
+      const elapsed = timeStamp - startTimeStamp;
+      progress.value = Math.max(0, Math.min(100, getProgress(duration, elapsed)));
+      if (import.meta.client) {
+        rafId = requestAnimationFrame(step);
+      }
+    }
+    if (import.meta.client) {
+      rafId = requestAnimationFrame(step);
+    }
+  }
+  let _cleanup = () => {
+  };
+  if (import.meta.client) {
+    const unsubLoadingStartHook = nuxtApp.hook("page:loading:start", () => {
+      start();
+    });
+    const unsubLoadingFinishHook = nuxtApp.hook("page:loading:end", () => {
+      finish();
+    });
+    const unsubError = nuxtApp.hook("vue:error", () => finish());
+    _cleanup = () => {
+      unsubError();
+      unsubLoadingStartHook();
+      unsubLoadingFinishHook();
+      clear();
+    };
+  }
+  return {
+    _cleanup,
+    progress: computed(() => progress.value),
+    isLoading: computed(() => isLoading.value),
+    error: computed(() => error.value),
+    start,
+    set,
+    finish,
+    clear
+  };
+}
+export function useLoadingIndicator(opts = {}) {
+  const nuxtApp = useNuxtApp();
+  const indicator = nuxtApp._loadingIndicator ||= createLoadingIndicator(opts);
+  if (import.meta.client && getCurrentScope()) {
+    nuxtApp._loadingIndicatorDeps ||= 0;
+    nuxtApp._loadingIndicatorDeps++;
+    onScopeDispose(() => {
+      nuxtApp._loadingIndicatorDeps--;
+      if (nuxtApp._loadingIndicatorDeps === 0) {
+        indicator._cleanup();
+        delete nuxtApp._loadingIndicator;
+      }
+    });
+  }
+  return indicator;
+}

package/dist/app/composables/manifest.d.ts

@@ -0,0 +1,20 @@
+import type { MatcherExport } from 'radix3';
+import type { H3Event } from 'h3';
+import type { NitroRouteRules } from 'nitropack/types';
+export interface NuxtAppManifestMeta {
+    id: string;
+    timestamp: number;
+}
+export interface NuxtAppManifest extends NuxtAppManifestMeta {
+    matcher: MatcherExport;
+    prerendered: string[];
+}
+/** @since 3.7.4 */
+export declare function getAppManifest(): Promise<NuxtAppManifest>;
+/** @since 3.7.4 */
+export declare function getRouteRules(event: H3Event): Promise<NitroRouteRules>;
+export declare function getRouteRules(options: {
+    path: string;
+}): Promise<Record<string, any>>;
+/** @deprecated use `getRouteRules({ path })` instead */
+export declare function getRouteRules(url: string): Promise<Record<string, any>>;

package/dist/app/composables/manifest.js

@@ -0,0 +1,59 @@
+import { createMatcherFromExport, createRouter as createRadixRouter, toRouteMatcher } from "radix3";
+import { defu } from "defu";
+import { useNuxtApp, useRuntimeConfig } from "../nuxt.js";
+import { appManifest as isAppManifestEnabled } from "#build/nuxt.config.mjs";
+import { buildAssetsURL } from "#internal/nuxt/paths";
+let manifest;
+let matcher;
+function fetchManifest() {
+  if (!isAppManifestEnabled) {
+    throw new Error("[nuxt] app manifest should be enabled with `experimental.appManifest`");
+  }
+  if (import.meta.server) {
+    manifest = import(
+      /* webpackIgnore: true */
+      /* @vite-ignore */
+      "#app-manifest"
+    );
+  } else {
+    manifest = $fetch(buildAssetsURL(`builds/meta/${useRuntimeConfig().app.buildId}.json`), {
+      responseType: "json"
+    });
+  }
+  manifest.then((m) => {
+    matcher = createMatcherFromExport(m.matcher);
+  }).catch((e) => {
+    console.error("[nuxt] Error fetching app manifest.", e);
+  });
+  return manifest;
+}
+export function getAppManifest() {
+  if (!isAppManifestEnabled) {
+    throw new Error("[nuxt] app manifest should be enabled with `experimental.appManifest`");
+  }
+  if (import.meta.server) {
+    useNuxtApp().ssrContext._preloadManifest = true;
+  }
+  return manifest || fetchManifest();
+}
+export async function getRouteRules(arg) {
+  const path = typeof arg === "string" ? arg : arg.path;
+  if (import.meta.server) {
+    useNuxtApp().ssrContext._preloadManifest = true;
+    const _routeRulesMatcher = toRouteMatcher(
+      createRadixRouter({ routes: useRuntimeConfig().nitro.routeRules })
+    );
+    return defu({}, ..._routeRulesMatcher.matchAll(path).reverse());
+  }
+  await getAppManifest();
+  if (!matcher) {
+    console.error("[nuxt] Error creating app manifest matcher.", matcher);
+    return {};
+  }
+  try {
+    return defu({}, ...matcher.matchAll(path).reverse());
+  } catch (e) {
+    console.error("[nuxt] Error matching route rules.", e);
+    return {};
+  }
+}

package/dist/app/composables/once.d.ts

@@ -0,0 +1,14 @@
+type CallOnceOptions = {
+    mode?: 'navigation' | 'render';
+};
+/**
+ * An SSR-friendly utility to call a method once
+ * @param key a unique key ensuring the function can be properly de-duplicated across requests
+ * @param fn a function to call
+ * @param options Setup the mode, e.g. to re-execute on navigation
+ * @see https://nuxt.com/docs/4.x/api/utils/call-once
+ * @since 3.9.0
+ */
+export declare function callOnce(key?: string, fn?: (() => any | Promise<any>), options?: CallOnceOptions): Promise<void>;
+export declare function callOnce(fn?: (() => any | Promise<any>), options?: CallOnceOptions): Promise<void>;
+export {};

package/dist/app/composables/once.js

@@ -0,0 +1,49 @@
+import { useRouter } from "./router.js";
+import { useNuxtApp } from "../nuxt.js";
+let _isHmrUpdating = false;
+export async function callOnce(...args) {
+  const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
+  if (typeof args[0] !== "string") {
+    args.unshift(autoKey);
+  }
+  const [_key, fn, options] = args;
+  if (!_key || typeof _key !== "string") {
+    throw new TypeError("[nuxt] [callOnce] key must be a string: " + _key);
+  }
+  if (fn !== void 0 && typeof fn !== "function") {
+    throw new Error("[nuxt] [callOnce] fn must be a function: " + fn);
+  }
+  const nuxtApp = useNuxtApp();
+  if (options?.mode === "navigation") {
+    let callback = function() {
+      nuxtApp.payload.once.delete(_key);
+      for (const cleanup of cleanups) {
+        cleanup();
+      }
+    };
+    const cleanups = [];
+    cleanups.push(nuxtApp.hooks.hook("page:start", callback), useRouter().beforeResolve(callback));
+  }
+  if (nuxtApp.payload.once.has(_key)) {
+    if (!import.meta.dev || !_isHmrUpdating) {
+      return;
+    }
+  }
+  nuxtApp._once ||= {};
+  nuxtApp._once[_key] ||= fn() || true;
+  await nuxtApp._once[_key];
+  nuxtApp.payload.once.add(_key);
+  delete nuxtApp._once[_key];
+}
+if (import.meta.hot) {
+  import.meta.hot.on("vite:beforeUpdate", (payload) => {
+    if (payload.updates.some((u) => u.type === "js-update")) {
+      _isHmrUpdating = true;
+    }
+  });
+  import.meta.hot.on("vite:afterUpdate", (payload) => {
+    if (payload.updates.some((u) => u.type === "js-update")) {
+      _isHmrUpdating = false;
+    }
+  });
+}

package/dist/app/composables/payload.d.ts

@@ -0,0 +1,27 @@
+import type { NuxtPayload } from '../nuxt.js';
+interface LoadPayloadOptions {
+    fresh?: boolean;
+    hash?: string;
+}
+/** @since 3.0.0 */
+export declare function loadPayload(url: string, opts?: LoadPayloadOptions): Promise<Record<string, any> | null>;
+/** @since 3.0.0 */
+export declare function preloadPayload(url: string, opts?: LoadPayloadOptions): Promise<void>;
+/** @since 3.0.0 */
+export declare function isPrerendered(url?: string): Promise<boolean>;
+/** @since 3.4.0 */
+export declare function getNuxtClientPayload(): Promise<Partial<NuxtPayload> | null>;
+export declare function parsePayload(payload: string): Promise<any>;
+/**
+ * This is an experimental function for configuring passing rich data from server -> client.
+ * @since 3.4.0
+ */
+export declare function definePayloadReducer(name: string, reduce: (data: any) => any): void;
+/**
+ * This is an experimental function for configuring passing rich data from server -> client.
+ *
+ * This function _must_ be called in a Nuxt plugin that is `unshift`ed to the beginning of the Nuxt plugins array.
+ * @since 3.4.0
+ */
+export declare function definePayloadReviver(name: string, revive: (data: any) => any | undefined): void;
+export {};

package/dist/app/composables/payload.js

@@ -0,0 +1,137 @@
+import { hasProtocol, joinURL } from "ufo";
+import { parse } from "devalue";
+import { getCurrentInstance, onServerPrefetch, reactive } from "vue";
+import { useNuxtApp, useRuntimeConfig } from "../nuxt.js";
+import { useHead } from "./head.js";
+import { useRoute } from "./router.js";
+import { getAppManifest, getRouteRules } from "./manifest.js";
+import { appId, appManifest, multiApp, payloadExtraction, renderJsonPayloads } from "#build/nuxt.config.mjs";
+export async function loadPayload(url, opts = {}) {
+  if (import.meta.server || !payloadExtraction) {
+    return null;
+  }
+  const shouldLoadPayload = await isPrerendered(url);
+  if (!shouldLoadPayload) {
+    return null;
+  }
+  const payloadURL = await _getPayloadURL(url, opts);
+  return await _importPayload(payloadURL) || null;
+}
+let linkRelType;
+function detectLinkRelType() {
+  if (import.meta.server) {
+    return "preload";
+  }
+  if (linkRelType) {
+    return linkRelType;
+  }
+  const relList = document.createElement("link").relList;
+  linkRelType = relList && relList.supports && relList.supports("prefetch") ? "prefetch" : "preload";
+  return linkRelType;
+}
+export function preloadPayload(url, opts = {}) {
+  const nuxtApp = useNuxtApp();
+  const promise = _getPayloadURL(url, opts).then((payloadURL) => {
+    const link = renderJsonPayloads ? { rel: detectLinkRelType(), as: "fetch", crossorigin: "anonymous", href: payloadURL } : { rel: "modulepreload", crossorigin: "", href: payloadURL };
+    if (import.meta.server) {
+      nuxtApp.runWithContext(() => useHead({ link: [link] }));
+    } else {
+      const linkEl = document.createElement("link");
+      for (const key of Object.keys(link)) {
+        linkEl[key === "crossorigin" ? "crossOrigin" : key] = link[key];
+      }
+      document.head.appendChild(linkEl);
+      return new Promise((resolve, reject) => {
+        linkEl.addEventListener("load", () => resolve());
+        linkEl.addEventListener("error", () => reject());
+      });
+    }
+  });
+  if (import.meta.server) {
+    onServerPrefetch(() => promise);
+  }
+  return promise;
+}
+const filename = renderJsonPayloads ? "_payload.json" : "_payload.js";
+async function _getPayloadURL(url, opts = {}) {
+  const u = new URL(url, "http://localhost");
+  if (u.host !== "localhost" || hasProtocol(u.pathname, { acceptRelative: true })) {
+    throw new Error("Payload URL must not include hostname: " + url);
+  }
+  const config = useRuntimeConfig();
+  const hash = opts.hash || (opts.fresh ? Date.now() : config.app.buildId);
+  const cdnURL = config.app.cdnURL;
+  const baseOrCdnURL = cdnURL && await isPrerendered(url) ? cdnURL : config.app.baseURL;
+  return joinURL(baseOrCdnURL, u.pathname, filename + (hash ? `?${hash}` : ""));
+}
+async function _importPayload(payloadURL) {
+  if (import.meta.server || !payloadExtraction) {
+    return null;
+  }
+  const payloadPromise = renderJsonPayloads ? fetch(payloadURL, { cache: "force-cache" }).then((res) => res.text().then(parsePayload)) : import(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    payloadURL
+  ).then((r) => r.default || r);
+  try {
+    return await payloadPromise;
+  } catch (err) {
+    console.warn("[nuxt] Cannot load payload ", payloadURL, err);
+  }
+  return null;
+}
+export async function isPrerendered(url = useRoute().path) {
+  const nuxtApp = useNuxtApp();
+  if (!appManifest) {
+    return !!nuxtApp.payload.prerenderedAt;
+  }
+  url = url === "/" ? url : url.replace(/\/$/, "");
+  const manifest = await getAppManifest();
+  if (manifest.prerendered.includes(url)) {
+    return true;
+  }
+  return nuxtApp.runWithContext(async () => {
+    const rules = await getRouteRules({ path: url });
+    return !!rules.prerender && !rules.redirect;
+  });
+}
+let payloadCache = null;
+export async function getNuxtClientPayload() {
+  if (import.meta.server) {
+    return null;
+  }
+  if (payloadCache) {
+    return payloadCache;
+  }
+  const el = multiApp ? document.querySelector(`[data-nuxt-data="${appId}"]`) : document.getElementById("__NUXT_DATA__");
+  if (!el) {
+    return {};
+  }
+  const inlineData = await parsePayload(el.textContent || "");
+  const externalData = el.dataset.src ? await _importPayload(el.dataset.src) : void 0;
+  payloadCache = {
+    ...inlineData,
+    ...externalData,
+    ...multiApp ? window.__NUXT__?.[appId] : window.__NUXT__
+  };
+  if (payloadCache.config?.public) {
+    payloadCache.config.public = reactive(payloadCache.config.public);
+  }
+  return payloadCache;
+}
+export async function parsePayload(payload) {
+  return await parse(payload, useNuxtApp()._payloadRevivers);
+}
+export function definePayloadReducer(name, reduce) {
+  if (import.meta.server) {
+    useNuxtApp().ssrContext._payloadReducers[name] = reduce;
+  }
+}
+export function definePayloadReviver(name, revive) {
+  if (import.meta.dev && getCurrentInstance()) {
+    console.warn("[nuxt] [definePayloadReviver] This function must be called in a Nuxt plugin that is `unshift`ed to the beginning of the Nuxt plugins array.");
+  }
+  if (import.meta.client) {
+    useNuxtApp()._payloadRevivers[name] = revive;
+  }
+}

package/dist/app/composables/preload.d.ts

@@ -0,0 +1,20 @@
+import type { Component } from 'vue';
+import type { RouteLocationRaw, Router } from 'vue-router';
+/**
+ * Preload a component or components that have been globally registered.
+ * @param components Pascal-cased name or names of components to prefetch
+ * @since 3.0.0
+ */
+export declare const preloadComponents: (components: string | string[]) => Promise<void>;
+/**
+ * Prefetch a component or components that have been globally registered.
+ * @param components Pascal-cased name or names of components to prefetch
+ * @since 3.0.0
+ */
+export declare const prefetchComponents: (components: string | string[]) => Promise<void> | undefined;
+export declare function _loadAsyncComponent(component: Component): any;
+/** @since 3.0.0 */
+export declare function preloadRouteComponents(to: RouteLocationRaw, router?: Router & {
+    _routePreloaded?: Set<string>;
+    _preloadPromises?: Array<Promise<unknown>>;
+}): Promise<void>;

package/dist/app/composables/preload.js

@@ -0,0 +1,55 @@
+import { useNuxtApp } from "../nuxt.js";
+import { toArray } from "../utils.js";
+import { useRouter } from "./router.js";
+export const preloadComponents = async (components) => {
+  if (import.meta.server) {
+    return;
+  }
+  const nuxtApp = useNuxtApp();
+  components = toArray(components);
+  await Promise.all(components.map((name) => {
+    const component = nuxtApp.vueApp._context.components[name];
+    if (component) {
+      return _loadAsyncComponent(component);
+    }
+  }));
+};
+export const prefetchComponents = (components) => {
+  if (import.meta.server) {
+    return;
+  }
+  return preloadComponents(components);
+};
+export function _loadAsyncComponent(component) {
+  if (component?.__asyncLoader && !component.__asyncResolved) {
+    return component.__asyncLoader();
+  }
+}
+export async function preloadRouteComponents(to, router = useRouter()) {
+  if (import.meta.server) {
+    return;
+  }
+  const { path, matched } = router.resolve(to);
+  if (!matched.length) {
+    return;
+  }
+  router._routePreloaded ||= /* @__PURE__ */ new Set();
+  if (router._routePreloaded.has(path)) {
+    return;
+  }
+  const promises = router._preloadPromises ||= [];
+  if (promises.length > 4) {
+    return Promise.all(promises).then(() => preloadRouteComponents(to, router));
+  }
+  router._routePreloaded.add(path);
+  for (const route of matched) {
+    const component = route.components?.default;
+    if (typeof component !== "function") {
+      continue;
+    }
+    const promise = Promise.resolve(component()).catch(() => {
+    }).finally(() => promises.splice(promises.indexOf(promise)));
+    promises.push(promise);
+  }
+  await Promise.all(promises);
+}

package/dist/app/composables/preview.d.ts

@@ -0,0 +1,38 @@
+interface Preview {
+    enabled: boolean;
+    state: Record<any, unknown>;
+    _initialized?: boolean;
+}
+/**
+ * Options for configuring preview mode.
+ */
+interface PreviewModeOptions<S> {
+    /**
+     * A function that determines whether preview mode should be enabled based on the current state.
+     * @param {Record<any, unknown>} state - The state of the preview.
+     * @returns {boolean} A boolean indicating whether the preview mode is enabled.
+     */
+    shouldEnable?: (state: Preview['state']) => boolean;
+    /**
+     * A function that retrieves the current state.
+     * The `getState` function will append returned values to current state, so be careful not to accidentally overwrite important state.
+     * @param {Record<any, unknown>} state - The preview state.
+     * @returns {Record<any, unknown>} The preview state.
+     */
+    getState?: (state: Preview['state']) => S;
+    /**
+     * A function to be called when the preview mode is enabled.
+     */
+    onEnable?: () => void;
+    /**
+     * A function to be called when the preview mode is disabled.
+     */
+    onDisable?: () => void;
+}
+type EnteredState = Record<any, unknown> | null | undefined | void;
+/** @since 3.11.0 */
+export declare function usePreviewMode<S extends EnteredState>(options?: PreviewModeOptions<S>): {
+    enabled: import("vue").Ref<boolean, boolean>;
+    state: S extends void ? Preview["state"] : (NonNullable<S> & Preview["state"]);
+};
+export {};

package/dist/app/composables/preview.js

@@ -0,0 +1,61 @@
+import { toRef, watch } from "vue";
+import { useState } from "./state.js";
+import { refreshNuxtData } from "./asyncData.js";
+import { useRoute, useRouter } from "./router.js";
+let unregisterRefreshHook;
+export function usePreviewMode(options = {}) {
+  const preview = useState("_preview-state", () => ({
+    enabled: false,
+    state: {}
+  }));
+  if (preview.value._initialized) {
+    return {
+      enabled: toRef(preview.value, "enabled"),
+      state: preview.value.state
+    };
+  }
+  if (import.meta.client) {
+    preview.value._initialized = true;
+  }
+  if (!preview.value.enabled) {
+    const shouldEnable = options.shouldEnable ?? defaultShouldEnable;
+    const result = shouldEnable(preview.value.state);
+    if (typeof result === "boolean") {
+      preview.value.enabled = result;
+    }
+  }
+  watch(() => preview.value.enabled, (value) => {
+    if (value) {
+      const getState = options.getState ?? getDefaultState;
+      const newState = getState(preview.value.state);
+      if (newState !== preview.value.state) {
+        Object.assign(preview.value.state, newState);
+      }
+      if (import.meta.client && !unregisterRefreshHook) {
+        const onEnable = options.onEnable ?? refreshNuxtData;
+        onEnable();
+        unregisterRefreshHook = options.onDisable ?? useRouter().afterEach(() => refreshNuxtData());
+      }
+    } else if (unregisterRefreshHook) {
+      unregisterRefreshHook();
+      unregisterRefreshHook = void 0;
+    }
+  }, { immediate: true, flush: "sync" });
+  return {
+    enabled: toRef(preview.value, "enabled"),
+    state: preview.value.state
+  };
+}
+function defaultShouldEnable() {
+  const route = useRoute();
+  const previewQueryName = "preview";
+  return route.query[previewQueryName] === "true";
+}
+function getDefaultState(state) {
+  if (state.token !== void 0) {
+    return state;
+  }
+  const route = useRoute();
+  state.token = Array.isArray(route.query.token) ? route.query.token[0] : route.query.token;
+  return state;
+}

package/dist/app/composables/ready.d.ts

@@ -0,0 +1,2 @@
+/** @since 3.1.0 */
+export declare const onNuxtReady: (callback: () => any) => void;

package/dist/app/composables/ready.js

@@ -0,0 +1,15 @@
+import { useNuxtApp } from "../nuxt.js";
+import { requestIdleCallback } from "../compat/idle-callback.js";
+export const onNuxtReady = (callback) => {
+  if (import.meta.server) {
+    return;
+  }
+  const nuxtApp = useNuxtApp();
+  if (nuxtApp.isHydrating) {
+    nuxtApp.hooks.hookOnce("app:suspense:resolve", () => {
+      requestIdleCallback(() => callback());
+    });
+  } else {
+    requestIdleCallback(() => callback());
+  }
+};

package/dist/app/composables/route-announcer.d.ts

@@ -0,0 +1,19 @@
+import type { Ref } from 'vue';
+export type Politeness = 'assertive' | 'polite' | 'off';
+export type NuxtRouteAnnouncerOpts = {
+    /** @default 'polite' */
+    politeness?: Politeness;
+};
+export type RouteAnnouncer = {
+    message: Ref<string>;
+    politeness: Ref<Politeness>;
+    set: (message: string, politeness: Politeness) => void;
+    polite: (message: string) => void;
+    assertive: (message: string) => void;
+    _cleanup: () => void;
+};
+/**
+ * composable to handle the route announcer
+ * @since 3.12.0
+ */
+export declare function useRouteAnnouncer(opts?: Partial<NuxtRouteAnnouncerOpts>): Omit<RouteAnnouncer, '_cleanup'>;