@depup/nuxt 4.3.0-depup.0 → 4.4.2-depup.1

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

@@ -17,21 +17,16 @@ export interface UseFetchOptions<ResT, DataT = ResT, PickKeys extends KeysOf<Dat
     watch?: MultiWatchSources | false;
 }
 /**
- * Fetch data from an API endpoint with an SSR-friendly composable.
- * See {@link https://nuxt.com/docs/4.x/api/composables/use-fetch}
- * @since 3.0.0
- * @param request The URL to fetch
- * @param opts extends $fetch options and useAsyncData options
+ * A factory function to create a custom `useFetch` composable with pre-defined default options.
+ * @since 4.2.0
  */
-export declare function useFetch<ResT = void, ErrorT = FetchError, ReqT extends NitroFetchRequest = NitroFetchRequest, Method extends AvailableRouterMethod<ReqT> = ResT extends void ? 'get' extends AvailableRouterMethod<ReqT> ? 'get' : AvailableRouterMethod<ReqT> : AvailableRouterMethod<ReqT>, _ResT = ResT extends void ? FetchResult<ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, ReqT, Method>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>;
-export declare function useFetch<ResT = void, ErrorT = FetchError, ReqT extends NitroFetchRequest = NitroFetchRequest, Method extends AvailableRouterMethod<ReqT> = ResT extends void ? 'get' extends AvailableRouterMethod<ReqT> ? 'get' : AvailableRouterMethod<ReqT> : AvailableRouterMethod<ReqT>, _ResT = ResT extends void ? FetchResult<ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, ReqT, Method>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>;
-/**
- * Fetch data from an API endpoint with an SSR-friendly composable.
- * See {@link https://nuxt.com/docs/4.x/api/composables/use-lazy-fetch}
- * @since 3.0.0
- * @param request The URL to fetch
- * @param opts extends $fetch options and useAsyncData options
- */
-export declare function useLazyFetch<ResT = void, ErrorT = FetchError, ReqT extends NitroFetchRequest = NitroFetchRequest, Method extends AvailableRouterMethod<ReqT> = ResT extends void ? 'get' extends AvailableRouterMethod<ReqT> ? 'get' : AvailableRouterMethod<ReqT> : AvailableRouterMethod<ReqT>, _ResT = ResT extends void ? FetchResult<ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: Omit<UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, ReqT, Method>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>;
-export declare function useLazyFetch<ResT = void, ErrorT = FetchError, ReqT extends NitroFetchRequest = NitroFetchRequest, Method extends AvailableRouterMethod<ReqT> = ResT extends void ? 'get' extends AvailableRouterMethod<ReqT> ? 'get' : AvailableRouterMethod<ReqT> : AvailableRouterMethod<ReqT>, _ResT = ResT extends void ? FetchResult<ReqT, Method> : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: Omit<UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, ReqT, Method>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>;
+export declare const createUseFetch: <FResT = void, FReqT extends NitroFetchRequest = NitroFetchRequest, FMethod extends AvailableRouterMethod<FReqT> = FResT extends void ? "get" extends AvailableRouterMethod<FReqT> ? "get" : AvailableRouterMethod<FReqT> : AvailableRouterMethod<FReqT>, F_ResT = FResT extends void ? FReqT extends string ? import("nitropack/types").MiddlewareOf<FReqT, Lowercase<FMethod>> extends never ? import("nitropack/types").MiddlewareOf<FReqT, "default"> extends never ? unknown : import("nitropack/types").MiddlewareOf<FReqT, "default"> : import("nitropack/types").MiddlewareOf<FReqT, Lowercase<FMethod>> : unknown : FResT, FDataT = F_ResT, FPickKeys extends KeysOf<FDataT> = KeysOf<FDataT>, FDefaultT = undefined>(options?: Partial<UseFetchOptions<F_ResT, FDataT, FPickKeys, FDefaultT, FReqT, FMethod>> | ((currentOptions: UseFetchOptions<unknown>) => Partial<UseFetchOptions<F_ResT, FDataT, FPickKeys, FDefaultT, FReqT, FMethod>>)) => {
+    <ResT = void, ErrorT = FetchError<any>, ReqT extends NitroFetchRequest = NitroFetchRequest, Method extends AvailableRouterMethod<ReqT> = ResT extends void ? "get" extends AvailableRouterMethod<ReqT> ? "get" : AvailableRouterMethod<ReqT> : AvailableRouterMethod<ReqT>, _ResT = ResT extends void ? ReqT extends string ? import("nitropack/types").MiddlewareOf<ReqT, Lowercase<Method>> extends never ? import("nitropack/types").MiddlewareOf<ReqT, "default"> extends never ? unknown : import("nitropack/types").MiddlewareOf<ReqT, "default"> : import("nitropack/types").MiddlewareOf<ReqT, Lowercase<Method>> : unknown : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, ReqT, Method>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>;
+    <ResT = void, ErrorT_1 = FetchError<any>, ReqT_1 extends NitroFetchRequest = NitroFetchRequest, Method_1 extends AvailableRouterMethod<ReqT_1> = ResT extends void ? "get" extends AvailableRouterMethod<ReqT_1> ? "get" : AvailableRouterMethod<ReqT_1> : AvailableRouterMethod<ReqT_1>, _ResT_1 = ResT extends void ? ReqT_1 extends string ? import("nitropack/types").MiddlewareOf<ReqT_1, Lowercase<Method_1>> extends never ? import("nitropack/types").MiddlewareOf<ReqT_1, "default"> extends never ? unknown : import("nitropack/types").MiddlewareOf<ReqT_1, "default"> : import("nitropack/types").MiddlewareOf<ReqT_1, Lowercase<Method_1>> : unknown : ResT, DataT_1 = _ResT_1, PickKeys_1 extends KeysOf<DataT_1> = KeysOf<DataT_1>, DefaultT_1 = DataT_1>(request: Ref<ReqT_1> | ReqT_1 | (() => ReqT_1), opts?: UseFetchOptions<_ResT_1, DataT_1, PickKeys_1, DefaultT_1, ReqT_1, Method_1>): AsyncData<PickFrom<DataT_1, PickKeys_1> | DefaultT_1, ErrorT_1 | undefined>;
+};
+export declare const useFetch: {
+    <ResT = void, ErrorT = FetchError<any>, ReqT extends NitroFetchRequest = NitroFetchRequest, Method extends AvailableRouterMethod<ReqT> = ResT extends void ? "get" extends AvailableRouterMethod<ReqT> ? AvailableRouterMethod<ReqT> & "get" : AvailableRouterMethod<ReqT> : AvailableRouterMethod<ReqT>, _ResT = ResT extends void ? ReqT extends string ? import("nitropack/types").MiddlewareOf<ReqT, Lowercase<Method>> extends never ? import("nitropack/types").MiddlewareOf<ReqT, "default"> extends never ? unknown : import("nitropack/types").MiddlewareOf<ReqT, "default"> : import("nitropack/types").MiddlewareOf<ReqT, Lowercase<Method>> : unknown : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(request: ReqT | Ref<ReqT, ReqT> | (() => ReqT), opts?: UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, ReqT, Method> | undefined): AsyncData<DefaultT | PickFrom<DataT, PickKeys>, ErrorT | undefined>;
+    <ResT = void, ErrorT = FetchError<any>, ReqT extends NitroFetchRequest = NitroFetchRequest, Method extends AvailableRouterMethod<ReqT> = ResT extends void ? "get" extends AvailableRouterMethod<ReqT> ? AvailableRouterMethod<ReqT> & "get" : AvailableRouterMethod<ReqT> : AvailableRouterMethod<ReqT>, _ResT = ResT extends void ? ReqT extends string ? import("nitropack/types").MiddlewareOf<ReqT, Lowercase<Method>> extends never ? import("nitropack/types").MiddlewareOf<ReqT, "default"> extends never ? unknown : import("nitropack/types").MiddlewareOf<ReqT, "default"> : import("nitropack/types").MiddlewareOf<ReqT, Lowercase<Method>> : unknown : ResT, DataT = _ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(request: ReqT | Ref<ReqT, ReqT> | (() => ReqT), opts?: UseFetchOptions<_ResT, DataT, PickKeys, DefaultT, ReqT, Method> | undefined): AsyncData<DefaultT | PickFrom<DataT, PickKeys>, ErrorT | undefined>;
+};
+export declare const useLazyFetch: ReturnType<typeof createUseFetch>;
 export {};

package/dist/app/composables/fetch.js

@@ -3,83 +3,8 @@ import { hash } from "ohash";
 import { isPlainObject } from "@vue/shared";
 import { useRequestFetch } from "./ssr.js";
 import { useAsyncData } from "./asyncData.js";
+import { defineKeyedFunctionFactory } from "../../compiler/runtime";
 import { alwaysRunFetchOnKeyChange, fetchDefaults } from "#build/nuxt.config.mjs";
-export function useFetch(request, arg1, arg2) {
-  const [opts = {}, autoKey] = typeof arg1 === "string" ? [{}, arg1] : [arg1, arg2];
-  const _request = computed(() => toValue(request));
-  const key = computed(() => toValue(opts.key) || "$f" + hash([autoKey, typeof _request.value === "string" ? _request.value : "", ...generateOptionSegments(opts)]));
-  if (!opts.baseURL && typeof _request.value === "string" && (_request.value[0] === "/" && _request.value[1] === "/")) {
-    throw new Error('[nuxt] [useFetch] the request URL must not start with "//".');
-  }
-  const {
-    server,
-    lazy,
-    default: defaultFn,
-    transform,
-    pick,
-    watch: watchSources,
-    immediate,
-    getCachedData,
-    deep,
-    dedupe,
-    timeout,
-    ...fetchOptions
-  } = opts;
-  const _fetchOptions = reactive({
-    ...fetchDefaults,
-    ...fetchOptions,
-    cache: typeof opts.cache === "boolean" ? void 0 : opts.cache
-  });
-  const _asyncDataOptions = {
-    server,
-    lazy,
-    default: defaultFn,
-    transform,
-    pick,
-    immediate,
-    getCachedData,
-    deep,
-    dedupe,
-    timeout,
-    watch: watchSources === false ? [] : [...watchSources || [], _fetchOptions]
-  };
-  if (import.meta.dev) {
-    _asyncDataOptions._functionName ||= "useFetch";
-  }
-  if (alwaysRunFetchOnKeyChange && !immediate) {
-    let setImmediate = function() {
-      _asyncDataOptions.immediate = true;
-    };
-    watch(key, setImmediate, { flush: "sync", once: true });
-    watch([...watchSources || [], _fetchOptions], setImmediate, { flush: "sync", once: true });
-  }
-  const asyncData = useAsyncData(watchSources === false ? key.value : key, (_, { signal }) => {
-    let _$fetch = opts.$fetch || globalThis.$fetch;
-    if (import.meta.server && !opts.$fetch) {
-      const isLocalFetch = typeof _request.value === "string" && _request.value[0] === "/" && (!toValue(opts.baseURL) || toValue(opts.baseURL)[0] === "/");
-      if (isLocalFetch) {
-        _$fetch = useRequestFetch();
-      }
-    }
-    return _$fetch(_request.value, { signal, ..._fetchOptions });
-  }, _asyncDataOptions);
-  return asyncData;
-}
-export function useLazyFetch(request, arg1, arg2) {
-  const [opts = {}, autoKey] = typeof arg1 === "string" ? [{}, arg1] : [arg1, arg2];
-  if (import.meta.dev) {
-    opts._functionName ||= "useLazyFetch";
-  }
-  return useFetch(
-    request,
-    {
-      ...opts,
-      lazy: true
-    },
-    // @ts-expect-error we pass an extra argument with the resolved auto-key to prevent another from being injected
-    autoKey
-  );
-}
 function generateOptionSegments(opts) {
   const segments = [
     toValue(opts.method)?.toUpperCase() || "GET",
@@ -121,3 +46,81 @@ function generateOptionSegments(opts) {
   }
   return segments;
 }
+export const createUseFetch = defineKeyedFunctionFactory({
+  name: "createUseFetch",
+  factory(options = {}) {
+    function useFetch2(request, arg1, arg2) {
+      const [opts = {}, autoKey] = typeof arg1 === "string" ? [{}, arg1] : [arg1, arg2];
+      const _request = computed(() => toValue(request));
+      const key = computed(() => toValue(opts.key) || "$f" + hash([autoKey, typeof _request.value === "string" ? _request.value : "", ...generateOptionSegments(opts)]));
+      if (!opts.baseURL && typeof _request.value === "string" && (_request.value[0] === "/" && _request.value[1] === "/")) {
+        throw new Error('[nuxt] [useFetch] the request URL must not start with "//".');
+      }
+      const factoryOptions = typeof options === "function" ? options(opts) : options;
+      const {
+        server,
+        lazy,
+        default: defaultFn,
+        transform,
+        pick,
+        watch: watchSources,
+        immediate,
+        getCachedData,
+        deep,
+        dedupe,
+        timeout,
+        ...fetchOptions
+      } = {
+        ...typeof options === "function" ? {} : factoryOptions,
+        ...opts,
+        ...typeof options === "function" ? factoryOptions : {}
+      };
+      const _fetchOptions = reactive({
+        ...fetchDefaults,
+        ...fetchOptions,
+        cache: typeof fetchOptions.cache === "boolean" ? void 0 : fetchOptions.cache
+      });
+      const _asyncDataOptions = {
+        server,
+        lazy,
+        default: defaultFn,
+        transform,
+        pick,
+        immediate,
+        getCachedData,
+        deep,
+        dedupe,
+        timeout,
+        watch: watchSources === false ? [] : [...watchSources || [], _fetchOptions]
+      };
+      if (import.meta.dev) {
+        _asyncDataOptions._functionName ||= factoryOptions._functionName || "useFetch";
+      }
+      if (alwaysRunFetchOnKeyChange && !immediate) {
+        let setImmediate = function() {
+          _asyncDataOptions.immediate = true;
+        };
+        watch(key, setImmediate, { flush: "sync", once: true });
+        watch([...watchSources || [], _fetchOptions], setImmediate, { flush: "sync", once: true });
+      }
+      const asyncData = useAsyncData(watchSources === false ? key.value : key, (_, { signal }) => {
+        let _$fetch = opts.$fetch || globalThis.$fetch;
+        if (import.meta.server && !opts.$fetch) {
+          const isLocalFetch = typeof _request.value === "string" && _request.value[0] === "/" && (!toValue(opts.baseURL) || toValue(opts.baseURL)[0] === "/");
+          if (isLocalFetch) {
+            _$fetch = useRequestFetch();
+          }
+        }
+        return _$fetch(_request.value, { signal, ..._fetchOptions });
+      }, _asyncDataOptions);
+      return asyncData;
+    }
+    return useFetch2;
+  }
+});
+export const useFetch = createUseFetch.__nuxt_factory();
+export const useLazyFetch = createUseFetch.__nuxt_factory({
+  lazy: true,
+  // @ts-expect-error private property
+  _functionName: "useLazyFetch"
+});

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

@@ -25,5 +25,7 @@ export { usePreviewMode } from './preview.js';
 export { useId } from './id.js';
 export { useRouteAnnouncer } from './route-announcer.js';
 export type { Politeness } from './route-announcer.js';
+export { useAnnouncer } from './announcer.js';
+export type { AnnouncerPoliteness, NuxtAnnouncer, NuxtAnnouncerOpts } from './announcer.js';
 export { useRuntimeHook } from './runtime-hook.js';
 export { injectHead, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta } from './head.js';

package/dist/app/composables/index.js

@@ -17,5 +17,6 @@ export { useRequestURL } from "./url.js";
 export { usePreviewMode } from "./preview.js";
 export { useId } from "./id.js";
 export { useRouteAnnouncer } from "./route-announcer.js";
+export { useAnnouncer } from "./announcer.js";
 export { useRuntimeHook } from "./runtime-hook.js";
 export { injectHead, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta } from "./head.js";

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

@@ -1,4 +1,4 @@
-import type { H3Event } from 'h3';
+import type { H3Event } from '@nuxt/nitro-server/h3';
 import type { NitroRouteRules } from 'nitropack/types';
 export interface NuxtAppManifestMeta {
     id: string;

package/dist/app/composables/manifest.js

@@ -1,4 +1,4 @@
-import { useNuxtApp, useRuntimeConfig } from "../nuxt.js";
+import { useRuntimeConfig } from "../nuxt.js";
 import { appManifest as isAppManifestEnabled } from "#build/nuxt.config.mjs";
 import { buildAssetsURL } from "#internal/nuxt/paths";
 import _routeRulesMatcher from "#build/route-rules.mjs";
@@ -28,9 +28,6 @@ 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 function getRouteRules(arg) {

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

@@ -0,0 +1,2 @@
+export type { PageMeta } from '#pages/composables';
+export { definePageMeta, defineRouteRules } from '#pages/composables';

package/dist/app/composables/pages.js

@@ -0,0 +1 @@
+export { definePageMeta, defineRouteRules } from "#pages/composables";

package/dist/app/composables/payload.js

@@ -30,7 +30,11 @@ function detectLinkRelType() {
 }
 export function preloadPayload(url, opts = {}) {
   const nuxtApp = useNuxtApp();
-  const promise = _getPayloadURL(url, opts).then((payloadURL) => {
+  const promise = shouldLoadPayload(url).then(async (shouldPreload) => {
+    if (!shouldPreload) {
+      return;
+    }
+    const payloadURL = await _getPayloadURL(url, opts);
     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] }));
@@ -58,7 +62,7 @@ async function _getPayloadURL(url, opts = {}) {
     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 hash = opts.hash || (opts.fresh || import.meta.dev ? 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}` : ""));
@@ -67,7 +71,7 @@ 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(
+  const payloadPromise = renderJsonPayloads ? fetch(payloadURL, import.meta.dev ? {} : { cache: "force-cache" }).then((res) => res.text().then(parsePayload)) : import(
     /* webpackIgnore: true */
     /* @vite-ignore */
     payloadURL
@@ -97,6 +101,9 @@ async function _isPrerenderedInManifest(url) {
 }
 export async function shouldLoadPayload(url = useRoute().path) {
   const rules = getRouteRules({ path: url });
+  if (rules.ssr === false) {
+    return false;
+  }
   const res = _shouldLoadPrerenderedPayload(rules);
   if (res !== void 0) {
     return res;
@@ -104,14 +111,16 @@ export async function shouldLoadPayload(url = useRoute().path) {
   if (rules.payload) {
     return true;
   }
-  return await _isPrerenderedInManifest(url);
+  const prerendered = await _isPrerenderedInManifest(url);
+  return prerendered;
 }
 export async function isPrerendered(url = useRoute().path) {
   const res = _shouldLoadPrerenderedPayload(getRouteRules({ path: url }));
   if (res !== void 0) {
     return res;
   }
-  return await _isPrerenderedInManifest(url);
+  const prerendered = await _isPrerenderedInManifest(url);
+  return prerendered;
 }
 let payloadCache = null;
 export async function getNuxtClientPayload() {

package/dist/app/composables/preload.js

@@ -48,7 +48,7 @@ export async function preloadRouteComponents(to, router = useRouter()) {
       continue;
     }
     const promise = Promise.resolve(component()).catch(() => {
-    }).finally(() => promises.splice(promises.indexOf(promise)));
+    }).finally(() => promises.splice(promises.indexOf(promise), 1));
     promises.push(promise);
   }
   await Promise.all(promises);

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

@@ -7,7 +7,7 @@ export type NuxtRouteAnnouncerOpts = {
 export type RouteAnnouncer = {
     message: Ref<string>;
     politeness: Ref<Politeness>;
-    set: (message: string, politeness: Politeness) => void;
+    set: (message: string, politeness?: Politeness) => void;
     polite: (message: string) => void;
     assertive: (message: string) => void;
     _cleanup: () => void;
@@ -16,4 +16,4 @@ export type RouteAnnouncer = {
  * composable to handle the route announcer
  * @since 3.12.0
  */
-export declare function useRouteAnnouncer(opts?: Partial<NuxtRouteAnnouncerOpts>): Omit<RouteAnnouncer, '_cleanup'>;
+export declare function useRouteAnnouncer(opts?: NuxtRouteAnnouncerOpts): Omit<RouteAnnouncer, '_cleanup'>;

package/dist/app/composables/route-announcer.js

@@ -9,11 +9,11 @@ function createRouteAnnouncer(opts = {}) {
     message.value = messageValue;
     politeness.value = politenessSetting;
   }
-  function polite(message2) {
-    return set(message2, "polite");
+  function polite(msg) {
+    set(msg, "polite");
   }
-  function assertive(message2) {
-    return set(message2, "assertive");
+  function assertive(msg) {
+    set(msg, "assertive");
   }
   function _updateMessageWithPageHeading() {
     set(document?.title?.trim(), politeness.value);
@@ -37,8 +37,8 @@ function createRouteAnnouncer(opts = {}) {
 export function useRouteAnnouncer(opts = {}) {
   const nuxtApp = useNuxtApp();
   const announcer = nuxtApp._routeAnnouncer ||= createRouteAnnouncer(opts);
-  if (opts.politeness !== announcer.politeness.value) {
-    announcer.politeness.value = opts.politeness || "polite";
+  if (opts.politeness && opts.politeness !== announcer.politeness.value) {
+    announcer.politeness.value = opts.politeness;
   }
   if (import.meta.client && getCurrentScope()) {
     nuxtApp._routeAnnouncerDeps ||= 0;

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

@@ -97,4 +97,11 @@ export declare function resolveRouteObject(to: Exclude<RouteLocationRaw, string>
  * @internal
  */
 export declare function encodeURL(location: string, isExternalHost?: boolean): string;
+/**
+ * Encode the pathname of a route location string. Ensures decoded paths like
+ * `/café` are percent-encoded to match vue-router's encoded route records.
+ * Already-encoded paths are not double-encoded.
+ * @internal
+ */
+export declare function encodeRoutePath(url: string): string;
 export {};

package/dist/app/composables/router.js

@@ -1,6 +1,6 @@
 import { getCurrentInstance, hasInjectionContext, inject, onScopeDispose } from "vue";
-import { sanitizeStatusCode } from "h3";
-import { hasProtocol, isScriptProtocol, joinURL, parseQuery, parseURL, withQuery } from "ufo";
+import { sanitizeStatusCode } from "@nuxt/nitro-server/h3";
+import { decodePath, encodePath, hasProtocol, isScriptProtocol, joinURL, parseQuery, parseURL, withQuery } from "ufo";
 import { useNuxtApp, useRuntimeConfig } from "../nuxt.js";
 import { PageRouteSymbol } from "../components/injections.js";
 import { createError, showError } from "./error.js";
@@ -145,7 +145,8 @@ export const navigateTo = (to, options) => {
     }
     return Promise.resolve();
   }
-  return options?.replace ? router.replace(to) : router.push(to);
+  const encodedTo = typeof to === "string" ? encodeRoutePath(to) : to;
+  return options?.replace ? router.replace(encodedTo) : router.push(encodedTo);
 };
 export const abortNavigation = (err) => {
   if (import.meta.dev && !isProcessingMiddleware()) {
@@ -199,3 +200,7 @@ export function encodeURL(location2, isExternalHost = false) {
   }
   return url.toString();
 }
+export function encodeRoutePath(url) {
+  const parsed = parseURL(url);
+  return encodePath(decodePath(parsed.pathname)) + parsed.search + parsed.hash;
+}

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

@@ -1,4 +1,4 @@
-import type { H3Event } from 'h3';
+import type { H3Event } from '@nuxt/nitro-server/h3';
 import type { H3Event$Fetch } from 'nitropack/types';
 import type { NuxtApp } from '../nuxt.js';
 /** @since 3.0.0 */

package/dist/app/composables/ssr.js

@@ -1,4 +1,4 @@
-import { setResponseStatus as _setResponseStatus, appendHeader, getRequestHeader, getRequestHeaders, getResponseHeader, removeResponseHeader, setResponseHeader } from "h3";
+import { setResponseStatus as _setResponseStatus, appendHeader, getRequestHeader, getRequestHeaders, getResponseHeader, removeResponseHeader, setResponseHeader } from "@nuxt/nitro-server/h3";
 import { computed, getCurrentInstance, ref } from "vue";
 import { useNuxtApp } from "../nuxt.js";
 import { toArray } from "../utils.js";

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

@@ -7,5 +7,15 @@ import type { Ref } from 'vue';
  */
 export declare function useState<T>(key?: string, init?: (() => T | Ref<T>)): Ref<T>;
 export declare function useState<T>(init?: (() => T | Ref<T>)): Ref<T>;
+export interface ClearNuxtStateOptions {
+    /**
+     * Reset the state to the initial value provided by the `init` function of `useState`
+     * instead of setting it to `undefined`.
+     *
+     * When not specified, this defaults to the value of `experimental.defaults.useState.resetOnClear`
+     * in your Nuxt config (which defaults to `true` with `compatibilityVersion: 5`).
+     */
+    reset?: boolean;
+}
 /** @since 3.6.0 */
-export declare function clearNuxtState(keys?: string | string[] | ((key: string) => boolean)): void;
+export declare function clearNuxtState(keys?: string | string[] | ((key: string) => boolean), opts?: ClearNuxtStateOptions): void;

package/dist/app/composables/state.js

@@ -1,6 +1,7 @@
 import { isRef, toRef } from "vue";
 import { useNuxtApp } from "../nuxt.js";
 import { toArray } from "../utils.js";
+import { useStateDefaults } from "#build/nuxt.config.mjs";
 const useStateKeyPrefix = "$s";
 export function useState(...args) {
   const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
@@ -17,6 +18,9 @@ export function useState(...args) {
   const key = useStateKeyPrefix + _key;
   const nuxtApp = useNuxtApp();
   const state = toRef(nuxtApp.payload.state, key);
+  if (init) {
+    nuxtApp._state[key] ??= { _default: init };
+  }
   if (state.value === void 0 && init) {
     const initialValue = init();
     if (isRef(initialValue)) {
@@ -27,14 +31,19 @@ export function useState(...args) {
   }
   return state;
 }
-export function clearNuxtState(keys) {
+export function clearNuxtState(keys, opts) {
+  const reset = opts?.reset ?? useStateDefaults.resetOnClear;
   const nuxtApp = useNuxtApp();
   const _allKeys = Object.keys(nuxtApp.payload.state).map((key) => key.substring(useStateKeyPrefix.length));
   const _keys = !keys ? _allKeys : typeof keys === "function" ? _allKeys.filter(keys) : toArray(keys);
   for (const _key of _keys) {
     const key = useStateKeyPrefix + _key;
     if (key in nuxtApp.payload.state) {
-      nuxtApp.payload.state[key] = void 0;
+      if (reset && nuxtApp._state[key]) {
+        nuxtApp.payload.state[key] = nuxtApp._state[key]._default();
+      } else {
+        nuxtApp.payload.state[key] = void 0;
+      }
     }
   }
 }

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

@@ -1,3 +1,3 @@
-import { getRequestURL } from 'h3';
+import { getRequestURL } from '@nuxt/nitro-server/h3';
 /** @since 3.5.0 */
 export declare function useRequestURL(opts?: Parameters<typeof getRequestURL>[1]): URL;

package/dist/app/composables/url.js

@@ -1,4 +1,4 @@
-import { getRequestURL } from "h3";
+import { getRequestURL } from "@nuxt/nitro-server/h3";
 import { useRequestEvent } from "./ssr.js";
 export function useRequestURL(opts) {
   if (import.meta.server) {

package/dist/app/config.d.ts

@@ -1,5 +1,5 @@
 import type { AppConfig } from 'nuxt/schema';
-type DeepPartial<T> = T extends Function ? T : T extends Record<string, any> ? {
+export type DeepPartial<T> = T extends Function ? T : T extends Record<string, any> ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
 export declare const _getAppConfig: () => AppConfig;
@@ -11,4 +11,3 @@ export declare function _replaceAppConfig(newConfig: AppConfig): void;
  * Will preserve existing properties.
  */
 export declare function updateAppConfig(appConfig: DeepPartial<AppConfig>): void;
-export {};

package/dist/app/index.d.ts

@@ -1,8 +1,8 @@
 import '../../dist/app/types/augments.js';
 export { applyPlugin, applyPlugins, callWithNuxt, createNuxtApp, defineAppConfig, defineNuxtPlugin, definePayloadPlugin, isNuxtPlugin, registerPluginHooks, tryUseNuxtApp, useNuxtApp, useRuntimeConfig } from './nuxt.js';
 export type { CreateOptions, NuxtApp, NuxtPayload, NuxtPluginIndicator, NuxtSSRContext, ObjectPlugin, Plugin, PluginEnvContext, PluginMeta, ResolvedPluginMeta, RuntimeNuxtHooks } from './nuxt.js';
-export { defineNuxtComponent, useAsyncData, useLazyAsyncData, useNuxtData, refreshNuxtData, clearNuxtData, useHydration, callOnce, useState, clearNuxtState, clearError, createError, isNuxtError, showError, useError, useFetch, useLazyFetch, useCookie, refreshCookie, onPrehydrate, prerenderRoutes, useRequestHeaders, useRequestEvent, useRequestFetch, setResponseStatus, useResponseHeader, onNuxtReady, abortNavigation, addRouteMiddleware, defineNuxtRouteMiddleware, onBeforeRouteLeave, onBeforeRouteUpdate, setPageLayout, navigateTo, useRoute, useRouter, preloadComponents, prefetchComponents, preloadRouteComponents, isPrerendered, loadPayload, preloadPayload, definePayloadReducer, definePayloadReviver, getAppManifest, getRouteRules, reloadNuxtApp, useRequestURL, usePreviewMode, useId, useRouteAnnouncer, useHead, useHeadSafe, useServerSeoMeta, useServerHeadSafe, useServerHead, useSeoMeta, injectHead, useRuntimeHook } from './composables/index.js';
-export type { AddRouteMiddlewareOptions, AsyncData, AsyncDataOptions, AsyncDataRequestStatus, CookieOptions, CookieRef, FetchResult, NuxtAppManifest, NuxtAppManifestMeta, NuxtError, Politeness, ReloadNuxtAppOptions, RouteMiddleware, UseFetchOptions } from './composables/index.js';
+export { defineNuxtComponent, useAsyncData, useLazyAsyncData, useNuxtData, refreshNuxtData, clearNuxtData, useHydration, callOnce, useState, clearNuxtState, clearError, createError, isNuxtError, showError, useError, useFetch, useLazyFetch, useCookie, refreshCookie, onPrehydrate, prerenderRoutes, useRequestHeaders, useRequestEvent, useRequestFetch, setResponseStatus, useResponseHeader, onNuxtReady, abortNavigation, addRouteMiddleware, defineNuxtRouteMiddleware, onBeforeRouteLeave, onBeforeRouteUpdate, setPageLayout, navigateTo, useRoute, useRouter, preloadComponents, prefetchComponents, preloadRouteComponents, isPrerendered, loadPayload, preloadPayload, definePayloadReducer, definePayloadReviver, getAppManifest, getRouteRules, reloadNuxtApp, useRequestURL, usePreviewMode, useId, useRouteAnnouncer, useAnnouncer, useHead, useHeadSafe, useServerSeoMeta, useServerHeadSafe, useServerHead, useSeoMeta, injectHead, useRuntimeHook } from './composables/index.js';
+export type { AddRouteMiddlewareOptions, AnnouncerPoliteness, AsyncData, AsyncDataOptions, AsyncDataRequestStatus, CookieOptions, CookieRef, FetchResult, NuxtAnnouncer, NuxtAnnouncerOpts, NuxtAppManifest, NuxtAppManifestMeta, NuxtError, Politeness, ReloadNuxtAppOptions, RouteMiddleware, UseFetchOptions } from './composables/index.js';
 export { defineNuxtLink } from './components/index.js';
 export type { NuxtLinkOptions, NuxtLinkProps, NuxtTimeProps } from './components/index.js';
 export { _getAppConfig, updateAppConfig, useAppConfig } from './config.js';

package/dist/app/index.js

@@ -1,6 +1,6 @@
 import "../../dist/app/types/augments";
 export { applyPlugin, applyPlugins, callWithNuxt, createNuxtApp, defineAppConfig, defineNuxtPlugin, definePayloadPlugin, isNuxtPlugin, registerPluginHooks, tryUseNuxtApp, useNuxtApp, useRuntimeConfig } from "./nuxt.js";
-export { defineNuxtComponent, useAsyncData, useLazyAsyncData, useNuxtData, refreshNuxtData, clearNuxtData, useHydration, callOnce, useState, clearNuxtState, clearError, createError, isNuxtError, showError, useError, useFetch, useLazyFetch, useCookie, refreshCookie, onPrehydrate, prerenderRoutes, useRequestHeaders, useRequestEvent, useRequestFetch, setResponseStatus, useResponseHeader, onNuxtReady, abortNavigation, addRouteMiddleware, defineNuxtRouteMiddleware, onBeforeRouteLeave, onBeforeRouteUpdate, setPageLayout, navigateTo, useRoute, useRouter, preloadComponents, prefetchComponents, preloadRouteComponents, isPrerendered, loadPayload, preloadPayload, definePayloadReducer, definePayloadReviver, getAppManifest, getRouteRules, reloadNuxtApp, useRequestURL, usePreviewMode, useId, useRouteAnnouncer, useHead, useHeadSafe, useServerSeoMeta, useServerHeadSafe, useServerHead, useSeoMeta, injectHead, useRuntimeHook } from "./composables/index.js";
+export { defineNuxtComponent, useAsyncData, useLazyAsyncData, useNuxtData, refreshNuxtData, clearNuxtData, useHydration, callOnce, useState, clearNuxtState, clearError, createError, isNuxtError, showError, useError, useFetch, useLazyFetch, useCookie, refreshCookie, onPrehydrate, prerenderRoutes, useRequestHeaders, useRequestEvent, useRequestFetch, setResponseStatus, useResponseHeader, onNuxtReady, abortNavigation, addRouteMiddleware, defineNuxtRouteMiddleware, onBeforeRouteLeave, onBeforeRouteUpdate, setPageLayout, navigateTo, useRoute, useRouter, preloadComponents, prefetchComponents, preloadRouteComponents, isPrerendered, loadPayload, preloadPayload, definePayloadReducer, definePayloadReviver, getAppManifest, getRouteRules, reloadNuxtApp, useRequestURL, usePreviewMode, useId, useRouteAnnouncer, useAnnouncer, useHead, useHeadSafe, useServerSeoMeta, useServerHeadSafe, useServerHead, useSeoMeta, injectHead, useRuntimeHook } from "./composables/index.js";
 export { defineNuxtLink } from "./components/index.js";
 export { _getAppConfig, updateAppConfig, useAppConfig } from "./config.js";
 export { cancelIdleCallback, requestIdleCallback } from "./compat/idle-callback.js";