@depup/nuxt 4.2.2-depup.0 → 4.4.2-depup.0

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

@@ -91,42 +91,24 @@ export interface _AsyncData<DataT, ErrorT> {
     status: Ref<AsyncDataRequestStatus>;
 }
 export type AsyncData<Data, Error> = _AsyncData<Data, Error> & Promise<_AsyncData<Data, Error>>;
-/**
- * Provides access to data that resolves asynchronously in an SSR-friendly composable.
- * See {@link https://nuxt.com/docs/4.x/api/composables/use-async-data}
- * @since 3.0.0
- * @param handler An asynchronous function that must return a truthy value (for example, it should not be `undefined` or `null`) or the request may be duplicated on the client side.
- * @param options customize the behavior of useAsyncData
- */
-export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(handler: AsyncDataHandler<ResT>, options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
-export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(handler: AsyncDataHandler<ResT>, options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
-/**
- * Provides access to data that resolves asynchronously in an SSR-friendly composable.
- * See {@link https://nuxt.com/docs/4.x/api/composables/use-async-data}
- * @param key A unique key to ensure that data fetching can be properly de-duplicated across requests.
- * @param handler An asynchronous function that must return a truthy value (for example, it should not be `undefined` or `null`) or the request may be duplicated on the client side.
- * @param options customize the behavior of useAsyncData
- */
-export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
-export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
-/**
- * Provides access to data that resolves asynchronously in an SSR-friendly composable.
- * See {@link https://nuxt.com/docs/4.x/api/composables/use-lazy-async-data}
- * @since 3.0.0
- * @param handler An asynchronous function that must return a truthy value (for example, it should not be `undefined` or `null`) or the request may be duplicated on the client side.
- * @param options customize the behavior of useLazyAsyncData
- */
-export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(handler: AsyncDataHandler<ResT>, options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
-export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(handler: AsyncDataHandler<ResT>, options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
-/**
- * Provides access to data that resolves asynchronously in an SSR-friendly composable.
- * See {@link https://nuxt.com/docs/4.x/api/composables/use-lazy-async-data}
- * @param key A unique key to ensure that data fetching can be properly de-duplicated across requests.
- * @param handler An asynchronous function that must return a truthy value (for example, it should not be `undefined` or `null`) or the request may be duplicated on the client side.
- * @param options customize the behavior of useLazyAsyncData
- */
-export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
-export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+export declare const createUseAsyncData: <FResT, FDataT = FResT, FPickKeys extends KeysOf<FDataT> = KeysOf<FDataT>, FDefaultT = undefined>(options?: Partial<AsyncDataOptions<FResT, FDataT, FPickKeys, FDefaultT>> | ((currentOptions: AsyncDataOptions<unknown>) => Partial<AsyncDataOptions<FResT, FDataT, FPickKeys, FDefaultT>>)) => {
+    <ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(handler: AsyncDataHandler<ResT>, opts?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+    <ResT, NuxtErrorDataT_1 = unknown, DataT_1 = ResT, PickKeys_1 extends KeysOf<DataT_1> = KeysOf<DataT_1>, DefaultT_1 = DataT_1>(handler: AsyncDataHandler<ResT>, opts?: AsyncDataOptions<ResT, DataT_1, PickKeys_1, DefaultT_1>): AsyncData<PickFrom<DataT_1, PickKeys_1> | DefaultT_1, (NuxtErrorDataT_1 extends Error | NuxtError ? NuxtErrorDataT_1 : NuxtError<NuxtErrorDataT_1>) | undefined>;
+    <ResT, NuxtErrorDataT_2 = unknown, DataT_2 = ResT, PickKeys_2 extends KeysOf<DataT_2> = KeysOf<DataT_2>, DefaultT_2 = undefined>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, opts?: AsyncDataOptions<ResT, DataT_2, PickKeys_2, DefaultT_2>): AsyncData<PickFrom<DataT_2, PickKeys_2> | DefaultT_2, (NuxtErrorDataT_2 extends Error | NuxtError ? NuxtErrorDataT_2 : NuxtError<NuxtErrorDataT_2>) | undefined>;
+    <ResT, NuxtErrorDataT_3 = unknown, DataT_3 = ResT, PickKeys_3 extends KeysOf<DataT_3> = KeysOf<DataT_3>, DefaultT_3 = DataT_3>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, opts?: AsyncDataOptions<ResT, DataT_3, PickKeys_3, DefaultT_3>): AsyncData<PickFrom<DataT_3, PickKeys_3> | DefaultT_3, (NuxtErrorDataT_3 extends Error | NuxtError ? NuxtErrorDataT_3 : NuxtError<NuxtErrorDataT_3>) | undefined>;
+};
+export declare const useAsyncData: {
+    <ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(handler: AsyncDataHandler<ResT>, opts?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT> | undefined): AsyncData<DefaultT | PickFrom<DataT, PickKeys>, (NuxtErrorDataT extends Error | NuxtError<unknown> ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+    <ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(handler: AsyncDataHandler<ResT>, opts?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT> | undefined): AsyncData<DefaultT | PickFrom<DataT, PickKeys>, (NuxtErrorDataT extends Error | NuxtError<unknown> ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+    <ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, opts?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT> | undefined): AsyncData<DefaultT | PickFrom<DataT, PickKeys>, (NuxtErrorDataT extends Error | NuxtError<unknown> ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+    <ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, opts?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT> | undefined): AsyncData<DefaultT | PickFrom<DataT, PickKeys>, (NuxtErrorDataT extends Error | NuxtError<unknown> ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+};
+export declare const useLazyAsyncData: {
+    <ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(handler: AsyncDataHandler<ResT>, opts?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT> | undefined): AsyncData<DefaultT | PickFrom<DataT, PickKeys>, (NuxtErrorDataT extends Error | NuxtError<unknown> ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+    <ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(handler: AsyncDataHandler<ResT>, opts?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT> | undefined): AsyncData<DefaultT | PickFrom<DataT, PickKeys>, (NuxtErrorDataT extends Error | NuxtError<unknown> ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+    <ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, opts?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT> | undefined): AsyncData<DefaultT | PickFrom<DataT, PickKeys>, (NuxtErrorDataT extends Error | NuxtError<unknown> ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+    <ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, opts?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT> | undefined): AsyncData<DefaultT | PickFrom<DataT, PickKeys>, (NuxtErrorDataT extends Error | NuxtError<unknown> ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+};
 /** @since 3.1.0 */
 export declare function useNuxtData<DataT = any>(key: string): {
     data: Ref<DataT | undefined>;
@@ -135,12 +117,17 @@ export declare function useNuxtData<DataT = any>(key: string): {
 export declare function refreshNuxtData(keys?: string | string[]): Promise<void>;
 /** @since 3.0.0 */
 export declare function clearNuxtData(keys?: string | string[] | ((key: string) => boolean)): void;
+export type DebouncedReturn<ArgumentsT extends unknown[], ReturnT> = ((...args: ArgumentsT) => Promise<ReturnT>) & {
+    cancel: () => void;
+    flush: () => Promise<ReturnT> | undefined;
+    isPending: () => boolean;
+};
 export type CreatedAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, DefaultT = undefined> = Omit<_AsyncData<DataT | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>)>, 'clear' | 'refresh'> & {
     _off: () => void;
     _hash?: Record<string, string | undefined>;
     _default: () => unknown;
     _init: boolean;
     _deps: number;
-    _execute: (opts?: AsyncDataExecuteOptions) => Promise<void>;
+    _execute: DebouncedReturn<[opts?: AsyncDataExecuteOptions | undefined], void>;
     _abortController?: AbortController;
 };

package/dist/app/composables/asyncData.js

@@ -6,190 +6,234 @@ import { getUserCaller, toArray } from "../utils.js";
 import { clientOnlySymbol } from "../components/client-only.js";
 import { createError } from "./error.js";
 import { onNuxtReady } from "./ready.js";
+import { defineKeyedFunctionFactory } from "../../compiler/runtime";
 import { asyncDataDefaults, granularCachedData, pendingWhenIdle, purgeCachedData } from "#build/nuxt.config.mjs";
-export function useAsyncData(...args) {
-  const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
-  if (_isAutoKeyNeeded(args[0], args[1])) {
-    args.unshift(autoKey);
-  }
-  let [_key, _handler, options = {}] = args;
-  let keyChanging = false;
-  const key = computed(() => toValue(_key));
-  if (typeof key.value !== "string") {
-    throw new TypeError("[nuxt] [useAsyncData] key must be a string.");
-  }
-  if (typeof _handler !== "function") {
-    throw new TypeError("[nuxt] [useAsyncData] handler must be a function.");
-  }
-  const nuxtApp = useNuxtApp();
-  options.server ??= true;
-  options.default ??= getDefault;
-  options.getCachedData ??= getDefaultCachedData;
-  options.lazy ??= false;
-  options.immediate ??= true;
-  options.deep ??= asyncDataDefaults.deep;
-  options.dedupe ??= "cancel";
-  const functionName = options._functionName || "useAsyncData";
-  const currentData = nuxtApp._asyncData[key.value];
-  if (import.meta.dev && currentData) {
-    const warnings = [];
-    const values = createHash(_handler, options);
-    if (values.handler !== currentData._hash?.handler) {
-      warnings.push(`different handler`);
-    }
-    for (const opt of ["transform", "pick", "getCachedData"]) {
-      if (values[opt] !== currentData._hash[opt]) {
-        warnings.push(`different \`${opt}\` option`);
+export const createUseAsyncData = defineKeyedFunctionFactory({
+  name: "createUseAsyncData",
+  factory(options = {}) {
+    function useAsyncData2(...args) {
+      const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
+      if (_isAutoKeyNeeded(args[0], args[1])) {
+        args.unshift(autoKey);
       }
-    }
-    if (currentData._default.toString() !== options.default.toString()) {
-      warnings.push(`different \`default\` value`);
-    }
-    if (options.deep && isShallow(currentData.data)) {
-      warnings.push(`mismatching \`deep\` option`);
-    }
-    if (warnings.length) {
-      const caller = getUserCaller();
-      const explanation = caller ? ` (used at ${caller.source}:${caller.line}:${caller.column})` : "";
-      console.warn(`[nuxt] [${functionName}] Incompatible options detected for "${key.value}"${explanation}:
-${warnings.map((w) => `- ${w}`).join("\n")}
-You can use a different key or move the call to a composable to ensure the options are shared across calls.`);
-    }
-  }
-  function createInitialFetch() {
-    const initialFetchOptions = { cause: "initial", dedupe: options.dedupe };
-    if (!nuxtApp._asyncData[key.value]?._init) {
-      initialFetchOptions.cachedData = options.getCachedData(key.value, nuxtApp, { cause: "initial" });
-      nuxtApp._asyncData[key.value] = createAsyncData(nuxtApp, key.value, _handler, options, initialFetchOptions.cachedData);
-    }
-    return () => nuxtApp._asyncData[key.value].execute(initialFetchOptions);
-  }
-  const initialFetch = createInitialFetch();
-  const asyncData = nuxtApp._asyncData[key.value];
-  asyncData._deps++;
-  const fetchOnServer = options.server !== false && nuxtApp.payload.serverRendered;
-  if (import.meta.server && fetchOnServer && options.immediate) {
-    const promise = initialFetch();
-    if (getCurrentInstance()) {
-      onServerPrefetch(() => promise);
-    } else {
-      nuxtApp.hook("app:created", async () => {
-        await promise;
-      });
-    }
-  }
-  if (import.meta.client) {
-    let unregister = function(key2) {
-      const data = nuxtApp._asyncData[key2];
-      if (data?._deps) {
-        data._deps--;
-        if (data._deps === 0) {
-          data?._off();
+      let [_key, _handler, opts = {}] = args;
+      let keyChanging = false;
+      const key = computed(() => toValue(_key));
+      if (typeof key.value !== "string") {
+        throw new TypeError("[nuxt] [useAsyncData] key must be a string.");
+      }
+      if (typeof _handler !== "function") {
+        throw new TypeError("[nuxt] [useAsyncData] handler must be a function.");
+      }
+      const shouldFactoryOptionsOverride = typeof options === "function";
+      const nuxtApp = useNuxtApp();
+      const factoryOptions = shouldFactoryOptionsOverride ? options(opts) : options;
+      if (!shouldFactoryOptionsOverride) {
+        for (const key2 in factoryOptions) {
+          if (factoryOptions[key2] === void 0) {
+            continue;
+          }
+          if (opts[key2] !== void 0) {
+            continue;
+          }
+          opts[key2] = factoryOptions[key2];
         }
       }
-    };
-    const instance = getCurrentInstance();
-    if (instance && fetchOnServer && options.immediate && !instance.sp) {
-      instance.sp = [];
-    }
-    if (import.meta.dev && !nuxtApp.isHydrating && !nuxtApp._processingMiddleware && (!instance || instance?.isMounted)) {
-      console.warn(`[nuxt] [${functionName}] Component is already mounted, please use $fetch instead. See https://nuxt.com/docs/4.x/getting-started/data-fetching`);
-    }
-    if (instance && !instance._nuxtOnBeforeMountCbs) {
-      instance._nuxtOnBeforeMountCbs = [];
-      const cbs = instance._nuxtOnBeforeMountCbs;
-      onBeforeMount(() => {
-        cbs.forEach((cb) => {
-          cb();
-        });
-        cbs.splice(0, cbs.length);
-      });
-      onUnmounted(() => cbs.splice(0, cbs.length));
-    }
-    const isWithinClientOnly = instance && (instance._nuxtClientOnly || inject(clientOnlySymbol, false));
-    if (fetchOnServer && nuxtApp.isHydrating && (asyncData.error.value || asyncData.data.value !== void 0)) {
-      if (pendingWhenIdle) {
-        asyncData.pending.value = false;
+      opts.server ??= true;
+      opts.default ??= getDefault;
+      opts.getCachedData ??= getDefaultCachedData;
+      opts.lazy ??= false;
+      opts.immediate ??= true;
+      opts.deep ??= asyncDataDefaults.deep;
+      opts.dedupe ??= "cancel";
+      if (shouldFactoryOptionsOverride) {
+        for (const key2 in factoryOptions) {
+          if (factoryOptions[key2] === void 0) {
+            continue;
+          }
+          opts[key2] = factoryOptions[key2];
+        }
       }
-      asyncData.status.value = asyncData.error.value ? "error" : "success";
-    } else if (instance && (!isWithinClientOnly && nuxtApp.payload.serverRendered && nuxtApp.isHydrating || options.lazy) && options.immediate) {
-      instance._nuxtOnBeforeMountCbs.push(initialFetch);
-    } else if (options.immediate && asyncData.status.value !== "success") {
-      initialFetch();
-    }
-    const hasScope = getCurrentScope();
-    const unsubKeyWatcher = watch(key, (newKey, oldKey) => {
-      if ((newKey || oldKey) && newKey !== oldKey) {
-        keyChanging = true;
-        const hadData = nuxtApp._asyncData[oldKey]?.data.value !== void 0;
-        const wasRunning = nuxtApp._asyncDataPromises[oldKey] !== void 0;
-        const initialFetchOptions = { cause: "initial", dedupe: options.dedupe };
-        if (!nuxtApp._asyncData[newKey]?._init) {
-          let initialValue;
-          if (oldKey && hadData) {
-            initialValue = nuxtApp._asyncData[oldKey].data.value;
-          } else {
-            initialValue = options.getCachedData(newKey, nuxtApp, { cause: "initial" });
-            initialFetchOptions.cachedData = initialValue;
+      const functionName = import.meta.dev ? factoryOptions._functionName || "useAsyncData" : "";
+      const currentData = nuxtApp._asyncData[key.value];
+      if (import.meta.dev && currentData) {
+        const warnings = [];
+        const values = createHash(_handler, opts);
+        if (values.handler !== currentData._hash?.handler) {
+          warnings.push(`different handler`);
+        }
+        for (const opt of ["transform", "pick", "getCachedData"]) {
+          if (values[opt] !== currentData._hash[opt]) {
+            warnings.push(`different \`${opt}\` option`);
           }
-          nuxtApp._asyncData[newKey] = createAsyncData(nuxtApp, newKey, _handler, options, initialValue);
         }
-        nuxtApp._asyncData[newKey]._deps++;
-        if (oldKey) {
-          unregister(oldKey);
+        if (currentData._default.toString() !== opts.default.toString()) {
+          warnings.push(`different \`default\` value`);
         }
-        if (options.immediate || hadData || wasRunning) {
-          nuxtApp._asyncData[newKey].execute(initialFetchOptions);
+        if (opts.deep && isShallow(currentData.data)) {
+          warnings.push(`mismatching \`deep\` option`);
+        }
+        if (warnings.length) {
+          const caller = getUserCaller();
+          const explanation = caller ? ` (used at ${caller.source}:${caller.line}:${caller.column})` : "";
+          console.warn(`[nuxt] [${functionName}] Incompatible options detected for "${key.value}"${explanation}:
+${warnings.map((w) => `- ${w}`).join("\n")}
+You can use a different key or move the call to a composable to ensure the options are shared across calls.`);
         }
-        queuePostFlushCb(() => {
-          keyChanging = false;
-        });
       }
-    }, { flush: "sync" });
-    const unsubParamsWatcher = options.watch ? watch(options.watch, () => {
-      if (keyChanging) {
-        return;
+      function createInitialFetch() {
+        const initialFetchOptions = { cause: "initial", dedupe: opts.dedupe };
+        if (!nuxtApp._asyncData[key.value]?._init) {
+          initialFetchOptions.cachedData = opts.getCachedData(key.value, nuxtApp, { cause: "initial" });
+          nuxtApp._asyncData[key.value] = buildAsyncData(nuxtApp, key.value, _handler, opts, initialFetchOptions.cachedData);
+        }
+        return () => nuxtApp._asyncData[key.value].execute(initialFetchOptions);
       }
-      nuxtApp._asyncData[key.value]?._execute({ cause: "watch", dedupe: options.dedupe });
-    }) : () => {
-    };
-    if (hasScope) {
-      onScopeDispose(() => {
-        unsubKeyWatcher();
-        unsubParamsWatcher();
-        unregister(key.value);
-      });
-    }
-  }
-  const asyncReturn = {
-    data: writableComputedRef(() => nuxtApp._asyncData[key.value]?.data),
-    pending: writableComputedRef(() => nuxtApp._asyncData[key.value]?.pending),
-    status: writableComputedRef(() => nuxtApp._asyncData[key.value]?.status),
-    error: writableComputedRef(() => nuxtApp._asyncData[key.value]?.error),
-    refresh: (...args2) => {
-      if (!nuxtApp._asyncData[key.value]?._init) {
-        const initialFetch2 = createInitialFetch();
-        return initialFetch2();
+      const initialFetch = createInitialFetch();
+      const asyncData = nuxtApp._asyncData[key.value];
+      asyncData._deps++;
+      const fetchOnServer = opts.server !== false && nuxtApp.payload.serverRendered;
+      if (import.meta.server && fetchOnServer && opts.immediate) {
+        const promise = initialFetch();
+        if (getCurrentInstance()) {
+          onServerPrefetch(() => promise);
+        } else {
+          nuxtApp.hook("app:created", async () => {
+            await promise;
+          });
+        }
       }
-      return nuxtApp._asyncData[key.value].execute(...args2);
-    },
-    execute: (...args2) => asyncReturn.refresh(...args2),
-    clear: () => {
-      const entry = nuxtApp._asyncData[key.value];
-      if (entry?._abortController) {
-        try {
-          entry._abortController.abort(new DOMException("AsyncData aborted by user.", "AbortError"));
-        } finally {
-          entry._abortController = void 0;
+      if (import.meta.client) {
+        let unregister = function(key2) {
+          const data = nuxtApp._asyncData[key2];
+          if (data?._deps) {
+            data._deps--;
+            if (data._deps === 0) {
+              data?._off();
+            }
+          }
+        };
+        const instance = getCurrentInstance();
+        if (instance && fetchOnServer && opts.immediate && !instance.sp) {
+          instance.sp = [];
+        }
+        if (import.meta.dev && !nuxtApp.isHydrating && !nuxtApp._processingMiddleware && (!instance || instance?.isMounted)) {
+          console.warn(`[nuxt] [${functionName}] Component is already mounted, please use $fetch instead. See https://nuxt.com/docs/4.x/getting-started/data-fetching`);
+        }
+        if (instance && !instance._nuxtOnBeforeMountCbs) {
+          instance._nuxtOnBeforeMountCbs = [];
+          const cbs = instance._nuxtOnBeforeMountCbs;
+          onBeforeMount(() => {
+            cbs.forEach((cb) => {
+              cb();
+            });
+            cbs.splice(0, cbs.length);
+          });
+          onUnmounted(() => cbs.splice(0, cbs.length));
+        }
+        const isWithinClientOnly = instance && (instance._nuxtClientOnly || inject(clientOnlySymbol, false));
+        if (fetchOnServer && nuxtApp.isHydrating && (asyncData.error.value || asyncData.data.value !== void 0)) {
+          if (pendingWhenIdle) {
+            asyncData.pending.value = false;
+          }
+          asyncData.status.value = asyncData.error.value ? "error" : "success";
+        } else if (instance && (!isWithinClientOnly && nuxtApp.payload.serverRendered && nuxtApp.isHydrating || opts.lazy) && opts.immediate) {
+          instance._nuxtOnBeforeMountCbs.push(initialFetch);
+        } else if (opts.immediate && asyncData.status.value !== "success") {
+          initialFetch();
+        }
+        const hasScope = getCurrentScope();
+        const unsubKeyWatcher = watch(key, (newKey, oldKey) => {
+          if ((newKey || oldKey) && newKey !== oldKey) {
+            keyChanging = true;
+            const hadData = nuxtApp._asyncData[oldKey]?.data.value !== void 0;
+            const wasRunning = nuxtApp._asyncDataPromises[oldKey] !== void 0;
+            const initialFetchOptions = { cause: "initial", dedupe: opts.dedupe };
+            if (!nuxtApp._asyncData[newKey]?._init) {
+              let initialValue;
+              if (oldKey && hadData) {
+                initialValue = nuxtApp._asyncData[oldKey].data.value;
+              } else {
+                initialValue = opts.getCachedData(newKey, nuxtApp, { cause: "initial" });
+                initialFetchOptions.cachedData = initialValue;
+              }
+              nuxtApp._asyncData[newKey] = buildAsyncData(nuxtApp, newKey, _handler, opts, initialValue);
+            }
+            nuxtApp._asyncData[newKey]._deps++;
+            if (oldKey) {
+              unregister(oldKey);
+            }
+            if (opts.immediate || hadData || wasRunning) {
+              nuxtApp._asyncData[newKey].execute(initialFetchOptions);
+            }
+            queuePostFlushCb(() => {
+              keyChanging = false;
+            });
+          }
+        }, { flush: "sync" });
+        const unsubParamsWatcher = opts.watch ? watch(opts.watch, () => {
+          if (keyChanging) {
+            return;
+          }
+          if (nuxtApp._asyncData[key.value]?._execute.isPending()) {
+            queuePostFlushCb(() => {
+              nuxtApp._asyncData[key.value]?._execute.flush();
+            });
+          }
+          nuxtApp._asyncData[key.value]?._execute({ cause: "watch", dedupe: opts.dedupe });
+        }) : () => {
+        };
+        if (hasScope) {
+          onScopeDispose(() => {
+            unsubKeyWatcher();
+            unsubParamsWatcher();
+            unregister(key.value);
+          });
         }
       }
-      clearNuxtDataByKey(nuxtApp, key.value);
+      const asyncReturn = {
+        data: writableComputedRef(() => nuxtApp._asyncData[key.value]?.data),
+        pending: writableComputedRef(() => nuxtApp._asyncData[key.value]?.pending),
+        status: writableComputedRef(() => nuxtApp._asyncData[key.value]?.status),
+        error: writableComputedRef(() => nuxtApp._asyncData[key.value]?.error),
+        refresh: (...args2) => {
+          if (!nuxtApp._asyncData[key.value]?._init) {
+            const initialFetch2 = createInitialFetch();
+            return initialFetch2();
+          }
+          return nuxtApp._asyncData[key.value].execute(...args2);
+        },
+        execute: (...args2) => asyncReturn.refresh(...args2),
+        clear: () => {
+          const entry = nuxtApp._asyncData[key.value];
+          if (entry?._abortController) {
+            try {
+              entry._abortController.abort(new DOMException("AsyncData aborted by user.", "AbortError"));
+            } finally {
+              entry._abortController = void 0;
+            }
+          }
+          clearNuxtDataByKey(nuxtApp, key.value);
+        }
+      };
+      const asyncDataPromise = Promise.resolve(nuxtApp._asyncDataPromises[key.value]).then(() => asyncReturn);
+      Object.assign(asyncDataPromise, asyncReturn);
+      Object.defineProperties(asyncDataPromise, {
+        then: { enumerable: true, value: asyncDataPromise.then.bind(asyncDataPromise) },
+        catch: { enumerable: true, value: asyncDataPromise.catch.bind(asyncDataPromise) },
+        finally: { enumerable: true, value: asyncDataPromise.finally.bind(asyncDataPromise) }
+      });
+      return asyncDataPromise;
     }
-  };
-  const asyncDataPromise = Promise.resolve(nuxtApp._asyncDataPromises[key.value]).then(() => asyncReturn);
-  Object.assign(asyncDataPromise, asyncReturn);
-  return asyncDataPromise;
-}
+    return useAsyncData2;
+  }
+});
+export const useAsyncData = createUseAsyncData.__nuxt_factory();
+export const useLazyAsyncData = createUseAsyncData.__nuxt_factory({
+  lazy: true,
+  // @ts-expect-error private property
+  _functionName: "useLazyAsyncData"
+});
 function writableComputedRef(getter) {
   return computed({
     get() {
@@ -203,17 +247,6 @@ function writableComputedRef(getter) {
     }
   });
 }
-export function useLazyAsyncData(...args) {
-  const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
-  if (_isAutoKeyNeeded(args[0], args[1])) {
-    args.unshift(autoKey);
-  }
-  const [key, handler, options = {}] = args;
-  if (import.meta.dev) {
-    options._functionName ||= "useLazyAsyncData";
-  }
-  return useAsyncData(key, handler, { ...options, lazy: true }, null);
-}
 function _isAutoKeyNeeded(keyOrFetcher, fetcher) {
   if (typeof keyOrFetcher === "string") {
     return false;
@@ -300,16 +333,16 @@ function pick(obj, keys) {
   }
   return newObj;
 }
-function createAsyncData(nuxtApp, key, _handler, options, initialCachedData) {
+function buildAsyncData(nuxtApp, key, _handler, options, initialCachedData) {
   nuxtApp.payload._errors[key] ??= void 0;
   const hasCustomGetCachedData = options.getCachedData !== getDefaultCachedData;
-  const handler = import.meta.client || !import.meta.prerender || !nuxtApp.ssrContext?._sharedPrerenderCache ? _handler : (nuxtApp2, options2) => {
-    const value = nuxtApp2.ssrContext._sharedPrerenderCache.get(key);
+  const handler = import.meta.client || !import.meta.prerender || !nuxtApp.ssrContext?.["~sharedPrerenderCache"] ? _handler : (nuxtApp2, options2) => {
+    const value = nuxtApp2.ssrContext["~sharedPrerenderCache"].get(key);
     if (value) {
       return value;
     }
     const promise = Promise.resolve().then(() => nuxtApp2.runWithContext(() => _handler(nuxtApp2, options2)));
-    nuxtApp2.ssrContext._sharedPrerenderCache.set(key, promise);
+    nuxtApp2.ssrContext["~sharedPrerenderCache"].set(key, promise);
     return promise;
   };
   const _ref = options.deep ? ref : shallowRef;

package/dist/app/composables/chunk.js

@@ -1,4 +1,3 @@
-import destr from "destr";
 import { useNuxtApp } from "../nuxt.js";
 export function reloadNuxtApp(options = {}) {
   if (import.meta.server) {
@@ -7,7 +6,7 @@ export function reloadNuxtApp(options = {}) {
   const path = options.path || window.location.pathname;
   let handledPath = {};
   try {
-    handledPath = destr(sessionStorage.getItem("nuxt:reload") || "{}");
+    handledPath = JSON.parse(sessionStorage.getItem("nuxt:reload") || "{}");
   } catch {
   }
   if (options.force || handledPath?.path !== path || handledPath?.expires < Date.now()) {

package/dist/app/composables/component.js

@@ -32,8 +32,7 @@ async function runLegacyAsyncData(res, fn) {
       _res[key2] = computed({
         get: () => data.value?.[key2],
         set(v) {
-          data.value ||= {};
-          data.value[key2] = v;
+          data.value = data.value ? { ...data.value, [key2]: v } : { [key2]: v };
         }
       });
     }

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

@@ -7,6 +7,20 @@ export interface CookieOptions<T = any> extends _CookieOptions {
     default?: () => T | Ref<T>;
     watch?: boolean | 'shallow';
     readonly?: boolean;
+    /**
+     * Refresh cookie expiration even when the value remains unchanged.
+     *
+     * By default, a cookie is only rewritten when its value changes.
+     * When `refresh` is set to `true`, the cookie will be re-written
+     * on every explicit assignment (e.g. `cookie.value = cookie.value`),
+     * extending its expiration even if the value is the same.
+     *
+     * Note: the expiration is not refreshed automatically — you must
+     * assign to `cookie.value` to trigger the refresh.
+     *
+     * @default false
+     */
+    refresh?: boolean;
 }
 export interface CookieRef<T> extends Ref<T> {
 }