@depup/nuxt 4.2.2-depup.0

package/dist/app/composables/asyncData.js

@@ -0,0 +1,491 @@
+import { computed, getCurrentInstance, getCurrentScope, inject, isShallow, nextTick, onBeforeMount, onScopeDispose, onServerPrefetch, onUnmounted, queuePostFlushCb, ref, shallowRef, toRef, toValue, unref, watch } from "vue";
+import { debounce } from "perfect-debounce";
+import { hash } from "ohash";
+import { useNuxtApp } from "../nuxt.js";
+import { getUserCaller, toArray } from "../utils.js";
+import { clientOnlySymbol } from "../components/client-only.js";
+import { createError } from "./error.js";
+import { onNuxtReady } from "./ready.js";
+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`);
+      }
+    }
+    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();
+        }
+      }
+    };
+    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;
+      }
+      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;
+          }
+          nuxtApp._asyncData[newKey] = createAsyncData(nuxtApp, newKey, _handler, options, initialValue);
+        }
+        nuxtApp._asyncData[newKey]._deps++;
+        if (oldKey) {
+          unregister(oldKey);
+        }
+        if (options.immediate || hadData || wasRunning) {
+          nuxtApp._asyncData[newKey].execute(initialFetchOptions);
+        }
+        queuePostFlushCb(() => {
+          keyChanging = false;
+        });
+      }
+    }, { flush: "sync" });
+    const unsubParamsWatcher = options.watch ? watch(options.watch, () => {
+      if (keyChanging) {
+        return;
+      }
+      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();
+      }
+      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);
+  return asyncDataPromise;
+}
+function writableComputedRef(getter) {
+  return computed({
+    get() {
+      return getter()?.value;
+    },
+    set(value) {
+      const ref2 = getter();
+      if (ref2) {
+        ref2.value = value;
+      }
+    }
+  });
+}
+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;
+  }
+  if (typeof keyOrFetcher === "object" && keyOrFetcher !== null) {
+    return false;
+  }
+  if (typeof keyOrFetcher === "function" && typeof fetcher === "function") {
+    return false;
+  }
+  return true;
+}
+export function useNuxtData(key) {
+  const nuxtApp = useNuxtApp();
+  if (!(key in nuxtApp.payload.data)) {
+    nuxtApp.payload.data[key] = void 0;
+  }
+  if (nuxtApp._asyncData[key]) {
+    const data = nuxtApp._asyncData[key];
+    data._deps++;
+    if (getCurrentScope()) {
+      onScopeDispose(() => {
+        data._deps--;
+        if (data._deps === 0) {
+          data?._off();
+        }
+      });
+    }
+  }
+  return {
+    data: computed({
+      get() {
+        return nuxtApp._asyncData[key]?.data.value ?? nuxtApp.payload.data[key];
+      },
+      set(value) {
+        if (nuxtApp._asyncData[key]) {
+          nuxtApp._asyncData[key].data.value = value;
+        } else {
+          nuxtApp.payload.data[key] = value;
+        }
+      }
+    })
+  };
+}
+export async function refreshNuxtData(keys) {
+  if (import.meta.server) {
+    return Promise.resolve();
+  }
+  await new Promise((resolve) => onNuxtReady(resolve));
+  const _keys = keys ? toArray(keys) : void 0;
+  await useNuxtApp().hooks.callHookParallel("app:data:refresh", _keys);
+}
+export function clearNuxtData(keys) {
+  const nuxtApp = useNuxtApp();
+  const _allKeys = Object.keys(nuxtApp.payload.data);
+  const _keys = !keys ? _allKeys : typeof keys === "function" ? _allKeys.filter(keys) : toArray(keys);
+  for (const key of _keys) {
+    clearNuxtDataByKey(nuxtApp, key);
+  }
+}
+function clearNuxtDataByKey(nuxtApp, key) {
+  if (key in nuxtApp.payload.data) {
+    nuxtApp.payload.data[key] = void 0;
+  }
+  if (key in nuxtApp.payload._errors) {
+    nuxtApp.payload._errors[key] = void 0;
+  }
+  if (nuxtApp._asyncData[key]) {
+    nuxtApp._asyncData[key].data.value = unref(nuxtApp._asyncData[key]._default());
+    nuxtApp._asyncData[key].error.value = void 0;
+    if (pendingWhenIdle) {
+      nuxtApp._asyncData[key].pending.value = false;
+    }
+    nuxtApp._asyncData[key].status.value = "idle";
+  }
+  if (key in nuxtApp._asyncDataPromises) {
+    nuxtApp._asyncDataPromises[key] = void 0;
+  }
+}
+function pick(obj, keys) {
+  const newObj = {};
+  for (const key of keys) {
+    newObj[key] = obj[key];
+  }
+  return newObj;
+}
+function createAsyncData(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);
+    if (value) {
+      return value;
+    }
+    const promise = Promise.resolve().then(() => nuxtApp2.runWithContext(() => _handler(nuxtApp2, options2)));
+    nuxtApp2.ssrContext._sharedPrerenderCache.set(key, promise);
+    return promise;
+  };
+  const _ref = options.deep ? ref : shallowRef;
+  const hasCachedData = initialCachedData !== void 0;
+  const unsubRefreshAsyncData = nuxtApp.hook("app:data:refresh", async (keys) => {
+    if (!keys || keys.includes(key)) {
+      await asyncData.execute({ cause: "refresh:hook" });
+    }
+  });
+  const asyncData = {
+    data: _ref(hasCachedData ? initialCachedData : options.default()),
+    pending: pendingWhenIdle ? shallowRef(!hasCachedData) : computed(() => asyncData.status.value === "pending"),
+    error: toRef(nuxtApp.payload._errors, key),
+    status: shallowRef("idle"),
+    execute: (...args) => {
+      const [_opts, newValue = void 0] = args;
+      const opts = _opts && newValue === void 0 && typeof _opts === "object" ? _opts : {};
+      if (import.meta.dev && newValue !== void 0 && (!_opts || typeof _opts !== "object")) {
+        console.warn(`[nuxt] [${options._functionName}] Do not pass \`execute\` directly to \`watch\`. Instead, use an inline function, such as \`watch(q, () => execute())\`.`);
+      }
+      if (nuxtApp._asyncDataPromises[key]) {
+        if ((opts.dedupe ?? options.dedupe) === "defer") {
+          return nuxtApp._asyncDataPromises[key];
+        }
+      }
+      if (granularCachedData || opts.cause === "initial" || nuxtApp.isHydrating) {
+        const cachedData = "cachedData" in opts ? opts.cachedData : options.getCachedData(key, nuxtApp, { cause: opts.cause ?? "refresh:manual" });
+        if (cachedData !== void 0) {
+          nuxtApp.payload.data[key] = asyncData.data.value = cachedData;
+          asyncData.error.value = void 0;
+          asyncData.status.value = "success";
+          return Promise.resolve(cachedData);
+        }
+      }
+      if (pendingWhenIdle) {
+        asyncData.pending.value = true;
+      }
+      if (asyncData._abortController) {
+        asyncData._abortController.abort(new DOMException("AsyncData request cancelled by deduplication", "AbortError"));
+      }
+      asyncData._abortController = new AbortController();
+      asyncData.status.value = "pending";
+      const cleanupController = new AbortController();
+      const promise = new Promise(
+        (resolve, reject) => {
+          try {
+            const timeout = opts.timeout ?? options.timeout;
+            const mergedSignal = mergeAbortSignals([asyncData._abortController?.signal, opts?.signal], cleanupController.signal, timeout);
+            if (mergedSignal.aborted) {
+              const reason = mergedSignal.reason;
+              reject(reason instanceof Error ? reason : new DOMException(String(reason ?? "Aborted"), "AbortError"));
+              return;
+            }
+            mergedSignal.addEventListener("abort", () => {
+              const reason = mergedSignal.reason;
+              reject(reason instanceof Error ? reason : new DOMException(String(reason ?? "Aborted"), "AbortError"));
+            }, { once: true, signal: cleanupController.signal });
+            return Promise.resolve(handler(nuxtApp, { signal: mergedSignal })).then(resolve, reject);
+          } catch (err) {
+            reject(err);
+          }
+        }
+      ).then(async (_result) => {
+        let result = _result;
+        if (options.transform) {
+          result = await options.transform(_result);
+        }
+        if (options.pick) {
+          result = pick(result, options.pick);
+        }
+        if (import.meta.dev && import.meta.server && typeof result === "undefined") {
+          const caller = getUserCaller();
+          const explanation = caller ? ` (used at ${caller.source}:${caller.line}:${caller.column})` : "";
+          console.warn(`[nuxt] \`${options._functionName || "useAsyncData"}${explanation}\` must return a value (it should not be \`undefined\`) or the request may be duplicated on the client side.`);
+        }
+        nuxtApp.payload.data[key] = result;
+        asyncData.data.value = result;
+        asyncData.error.value = void 0;
+        asyncData.status.value = "success";
+      }).catch((error) => {
+        if (nuxtApp._asyncDataPromises[key] && nuxtApp._asyncDataPromises[key] !== promise) {
+          return nuxtApp._asyncDataPromises[key];
+        }
+        if (asyncData._abortController?.signal.aborted) {
+          return nuxtApp._asyncDataPromises[key];
+        }
+        if (typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError") {
+          asyncData.status.value = "idle";
+          return nuxtApp._asyncDataPromises[key];
+        }
+        asyncData.error.value = createError(error);
+        asyncData.data.value = unref(options.default());
+        asyncData.status.value = "error";
+      }).finally(() => {
+        if (pendingWhenIdle) {
+          asyncData.pending.value = false;
+        }
+        cleanupController.abort();
+        delete nuxtApp._asyncDataPromises[key];
+      });
+      nuxtApp._asyncDataPromises[key] = promise;
+      return nuxtApp._asyncDataPromises[key];
+    },
+    _execute: debounce((...args) => asyncData.execute(...args), 0, { leading: true }),
+    _default: options.default,
+    _deps: 0,
+    _init: true,
+    _hash: import.meta.dev ? createHash(_handler, options) : void 0,
+    _off: () => {
+      unsubRefreshAsyncData();
+      if (nuxtApp._asyncData[key]?._init) {
+        nuxtApp._asyncData[key]._init = false;
+      }
+      if (purgeCachedData && !hasCustomGetCachedData) {
+        nextTick(() => {
+          if (!nuxtApp._asyncData[key]?._init) {
+            clearNuxtDataByKey(nuxtApp, key);
+            asyncData.execute = () => Promise.resolve();
+          }
+        });
+      }
+    }
+  };
+  return asyncData;
+}
+const getDefault = () => void 0;
+const getDefaultCachedData = (key, nuxtApp, ctx) => {
+  if (nuxtApp.isHydrating) {
+    return nuxtApp.payload.data[key];
+  }
+  if (ctx.cause !== "refresh:manual" && ctx.cause !== "refresh:hook") {
+    return nuxtApp.static.data[key];
+  }
+};
+function createHash(_handler, options) {
+  return {
+    handler: hash(_handler),
+    transform: options.transform ? hash(options.transform) : void 0,
+    pick: options.pick ? hash(options.pick) : void 0,
+    getCachedData: options.getCachedData ? hash(options.getCachedData) : void 0
+  };
+}
+function mergeAbortSignals(signals, cleanupSignal, timeout) {
+  const list = signals.filter((s) => !!s);
+  if (typeof timeout === "number" && timeout >= 0) {
+    const timeoutSignal = AbortSignal.timeout?.(timeout);
+    if (timeoutSignal) {
+      list.push(timeoutSignal);
+    }
+  }
+  if (AbortSignal.any) {
+    return AbortSignal.any(list);
+  }
+  const controller = new AbortController();
+  for (const sig of list) {
+    if (sig.aborted) {
+      const reason = sig.reason ?? new DOMException("Aborted", "AbortError");
+      try {
+        controller.abort(reason);
+      } catch {
+        controller.abort();
+      }
+      return controller.signal;
+    }
+  }
+  const onAbort = () => {
+    const abortedSignal = list.find((s) => s.aborted);
+    const reason = abortedSignal?.reason ?? new DOMException("Aborted", "AbortError");
+    try {
+      controller.abort(reason);
+    } catch {
+      controller.abort();
+    }
+  };
+  for (const sig of list) {
+    sig.addEventListener?.("abort", onAbort, { once: true, signal: cleanupSignal });
+  }
+  return controller.signal;
+}

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

@@ -0,0 +1,25 @@
+export interface ReloadNuxtAppOptions {
+    /**
+     * Number of milliseconds in which to ignore future reload requests
+     * @default {10000}
+     */
+    ttl?: number;
+    /**
+     * Force a reload even if one has occurred within the previously specified TTL.
+     * @default {false}
+     */
+    force?: boolean;
+    /**
+     * Whether to dump the current Nuxt state to sessionStorage (as `nuxt:reload:state`).
+     * @default {false}
+     */
+    persistState?: boolean;
+    /**
+     * The path to reload. If this is different from the current window location it will
+     * trigger a navigation and add an entry in the browser history.
+     * @default {window.location.pathname}
+     */
+    path?: string;
+}
+/** @since 3.3.0 */
+export declare function reloadNuxtApp(options?: ReloadNuxtAppOptions): void;

package/dist/app/composables/chunk.js

@@ -0,0 +1,30 @@
+import destr from "destr";
+import { useNuxtApp } from "../nuxt.js";
+export function reloadNuxtApp(options = {}) {
+  if (import.meta.server) {
+    return;
+  }
+  const path = options.path || window.location.pathname;
+  let handledPath = {};
+  try {
+    handledPath = destr(sessionStorage.getItem("nuxt:reload") || "{}");
+  } catch {
+  }
+  if (options.force || handledPath?.path !== path || handledPath?.expires < Date.now()) {
+    try {
+      sessionStorage.setItem("nuxt:reload", JSON.stringify({ path, expires: Date.now() + (options.ttl ?? 1e4) }));
+    } catch {
+    }
+    if (options.persistState) {
+      try {
+        sessionStorage.setItem("nuxt:reload:state", JSON.stringify({ state: useNuxtApp().payload.state }));
+      } catch {
+      }
+    }
+    if (window.location.pathname !== path) {
+      window.location.href = path;
+    } else {
+      window.location.reload();
+    }
+  }
+}

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

@@ -0,0 +1,4 @@
+import type { defineComponent } from 'vue';
+export declare const NuxtComponentIndicator = "__nuxt_component";
+/** @since 3.0.0 */
+export declare const defineNuxtComponent: typeof defineComponent;

package/dist/app/composables/component.js

@@ -0,0 +1,82 @@
+import { computed, getCurrentInstance } from "vue";
+import { hash } from "ohash";
+import { getNuxtAppCtx, useNuxtApp } from "../nuxt.js";
+import { useHead } from "./head.js";
+import { useAsyncData } from "./asyncData.js";
+import { useRoute } from "./router.js";
+import { createError } from "./error.js";
+export const NuxtComponentIndicator = "__nuxt_component";
+// @__NO_SIDE_EFFECTS__
+function getFetchKey() {
+  const vm = getCurrentInstance();
+  const route = useRoute();
+  const { _fetchKeyBase } = vm.proxy.$options;
+  return hash([
+    _fetchKeyBase,
+    route.path,
+    route.query,
+    route.matched.findIndex((r) => Object.values(r.components || {}).includes(vm.type))
+  ]);
+}
+async function runLegacyAsyncData(res, fn) {
+  const nuxtApp = useNuxtApp();
+  const { fetchKey } = getCurrentInstance().proxy.$options;
+  const key = (typeof fetchKey === "function" ? fetchKey(() => "") : fetchKey) || /* @__PURE__ */ getFetchKey();
+  const { data, error } = await useAsyncData(`options:asyncdata:${key}`, () => import.meta.server ? nuxtApp.runWithContext(() => fn(nuxtApp)) : fn(nuxtApp));
+  if (error.value) {
+    throw createError(error.value);
+  }
+  if (data.value && typeof data.value === "object") {
+    const _res = await res;
+    for (const key2 in data.value) {
+      _res[key2] = computed({
+        get: () => data.value?.[key2],
+        set(v) {
+          data.value ||= {};
+          data.value[key2] = v;
+        }
+      });
+    }
+  } else if (import.meta.dev) {
+    console.warn("[nuxt] asyncData should return an object", data);
+  }
+}
+export const defineNuxtComponent = /* @__NO_SIDE_EFFECTS__ */ function defineNuxtComponent2(...args) {
+  const [options, key] = args;
+  const { setup } = options;
+  if (!setup && !options.asyncData && !options.head) {
+    return {
+      [NuxtComponentIndicator]: true,
+      ...options
+    };
+  }
+  return {
+    [NuxtComponentIndicator]: true,
+    _fetchKeyBase: key,
+    ...options,
+    setup(props, ctx) {
+      const nuxtApp = useNuxtApp();
+      let res = {};
+      if (setup) {
+        const fn = () => Promise.resolve(setup(props, ctx)).then((r) => r || {});
+        const nuxtAppCtx = getNuxtAppCtx(nuxtApp._id);
+        if (import.meta.server) {
+          res = nuxtAppCtx.callAsync(nuxtApp, fn);
+        } else {
+          nuxtAppCtx.set(nuxtApp);
+          res = fn();
+        }
+      }
+      const promises = [];
+      if (options.asyncData) {
+        promises.push(runLegacyAsyncData(res, options.asyncData));
+      }
+      if (options.head) {
+        useHead(typeof options.head === "function" ? () => options.head(nuxtApp) : options.head);
+      }
+      return Promise.resolve(res).then(() => Promise.all(promises)).then(() => res).finally(() => {
+        promises.length = 0;
+      });
+    }
+  };
+};

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

@@ -0,0 +1,22 @@
+import type { Ref } from 'vue';
+import type { CookieParseOptions, CookieSerializeOptions } from 'cookie-es';
+type _CookieOptions = Omit<CookieSerializeOptions & CookieParseOptions, 'decode' | 'encode'>;
+export interface CookieOptions<T = any> extends _CookieOptions {
+    decode?(value: string): T;
+    encode?(value: T): string;
+    default?: () => T | Ref<T>;
+    watch?: boolean | 'shallow';
+    readonly?: boolean;
+}
+export interface CookieRef<T> extends Ref<T> {
+}
+/** @since 3.0.0 */
+export declare function useCookie<T = string | null | undefined>(name: string, _opts?: CookieOptions<T> & {
+    readonly?: false;
+}): CookieRef<T>;
+export declare function useCookie<T = string | null | undefined>(name: string, _opts: CookieOptions<T> & {
+    readonly: true;
+}): Readonly<CookieRef<T>>;
+/** @since 3.10.0 */
+export declare function refreshCookie(name: string): void;
+export {};