@depup/nuxt 4.2.2-depup.0

package/dist/app/composables/cookie.js

@@ -0,0 +1,205 @@
+import { customRef, getCurrentScope, nextTick, onScopeDispose, ref, watch } from "vue";
+import { parse, serialize } from "cookie-es";
+import { deleteCookie, getCookie, getRequestHeader, setCookie } from "h3";
+import destr from "destr";
+import { isEqual } from "ohash";
+import { klona } from "klona";
+import { useNuxtApp } from "../nuxt.js";
+import { useRequestEvent } from "./ssr.js";
+import { cookieStore } from "#build/nuxt.config.mjs";
+const CookieDefaults = {
+  path: "/",
+  watch: true,
+  decode: (val) => destr(decodeURIComponent(val)),
+  encode: (val) => encodeURIComponent(typeof val === "string" ? val : JSON.stringify(val))
+};
+const store = import.meta.client && cookieStore ? globalThis.cookieStore : void 0;
+export function useCookie(name, _opts) {
+  const opts = { ...CookieDefaults, ..._opts };
+  opts.filter ??= (key) => key === name;
+  const cookies = readRawCookies(opts) || {};
+  let delay;
+  if (opts.maxAge !== void 0) {
+    delay = opts.maxAge * 1e3;
+  } else if (opts.expires) {
+    delay = opts.expires.getTime() - Date.now();
+  }
+  const hasExpired = delay !== void 0 && delay <= 0;
+  const shouldSetInitialClientCookie = import.meta.client && (hasExpired || cookies[name] === void 0 || cookies[name] === null);
+  const cookieValue = klona(hasExpired ? void 0 : cookies[name] ?? opts.default?.());
+  const cookie = import.meta.client && delay && !hasExpired ? cookieRef(cookieValue, delay, opts.watch && opts.watch !== "shallow") : ref(cookieValue);
+  if (import.meta.dev && hasExpired) {
+    console.warn(`[nuxt] not setting cookie \`${name}\` as it has already expired.`);
+  }
+  if (import.meta.client) {
+    let channel = null;
+    try {
+      if (!store && typeof BroadcastChannel !== "undefined") {
+        channel = new BroadcastChannel(`nuxt:cookies:${name}`);
+      }
+    } catch {
+    }
+    const callback = (force = false) => {
+      if (!force) {
+        if (opts.readonly || isEqual(cookie.value, cookies[name])) {
+          return;
+        }
+      }
+      writeClientCookie(name, cookie.value, opts);
+      cookies[name] = klona(cookie.value);
+      channel?.postMessage({ value: opts.encode(cookie.value) });
+    };
+    const handleChange = (data) => {
+      const value = data.refresh ? readRawCookies(opts)?.[name] : opts.decode(data.value);
+      watchPaused = true;
+      cookie.value = value;
+      cookies[name] = klona(value);
+      nextTick(() => {
+        watchPaused = false;
+      });
+    };
+    let watchPaused = false;
+    const hasScope = !!getCurrentScope();
+    if (hasScope) {
+      onScopeDispose(() => {
+        watchPaused = true;
+        callback();
+        channel?.close();
+      });
+    }
+    if (store) {
+      const changeHandler = (event) => {
+        const changedCookie = event.changed.find((c) => c.name === name);
+        const removedCookie = event.deleted.find((c) => c.name === name);
+        if (changedCookie) {
+          handleChange({ value: changedCookie.value });
+        }
+        if (removedCookie) {
+          handleChange({ value: null });
+        }
+      };
+      store.addEventListener("change", changeHandler);
+      if (hasScope) {
+        onScopeDispose(() => store.removeEventListener("change", changeHandler));
+      }
+    } else if (channel) {
+      channel.onmessage = ({ data }) => handleChange(data);
+    }
+    if (opts.watch) {
+      watch(
+        cookie,
+        () => {
+          if (watchPaused) {
+            return;
+          }
+          callback();
+        },
+        { deep: opts.watch !== "shallow" }
+      );
+    }
+    if (shouldSetInitialClientCookie) {
+      callback(shouldSetInitialClientCookie);
+    }
+  } else if (import.meta.server) {
+    const nuxtApp = useNuxtApp();
+    const writeFinalCookieValue = () => {
+      if (opts.readonly || isEqual(cookie.value, cookies[name])) {
+        return;
+      }
+      nuxtApp._cookies ||= {};
+      if (name in nuxtApp._cookies) {
+        if (isEqual(cookie.value, nuxtApp._cookies[name])) {
+          return;
+        }
+        if (import.meta.dev) {
+          console.warn(`[nuxt] cookie \`${name}\` was previously set to \`${opts.encode(nuxtApp._cookies[name])}\` and is being overridden to \`${opts.encode(cookie.value)}\`. This may cause unexpected issues.`);
+        }
+      }
+      nuxtApp._cookies[name] = cookie.value;
+      writeServerCookie(useRequestEvent(nuxtApp), name, cookie.value, opts);
+    };
+    const unhook = nuxtApp.hooks.hookOnce("app:rendered", writeFinalCookieValue);
+    nuxtApp.hooks.hookOnce("app:error", () => {
+      unhook();
+      return writeFinalCookieValue();
+    });
+  }
+  return cookie;
+}
+export function refreshCookie(name) {
+  if (import.meta.server || store || typeof BroadcastChannel === "undefined") {
+    return;
+  }
+  new BroadcastChannel(`nuxt:cookies:${name}`)?.postMessage({ refresh: true });
+}
+function readRawCookies(opts = {}) {
+  if (import.meta.server) {
+    return parse(getRequestHeader(useRequestEvent(), "cookie") || "", opts);
+  } else if (import.meta.client) {
+    return parse(document.cookie, opts);
+  }
+}
+function serializeCookie(name, value, opts = {}) {
+  if (value === null || value === void 0) {
+    return serialize(name, value, { ...opts, maxAge: -1 });
+  }
+  return serialize(name, value, opts);
+}
+function writeClientCookie(name, value, opts = {}) {
+  if (import.meta.client) {
+    document.cookie = serializeCookie(name, value, opts);
+  }
+}
+function writeServerCookie(event, name, value, opts = {}) {
+  if (event) {
+    if (value !== null && value !== void 0) {
+      return setCookie(event, name, value, opts);
+    }
+    if (getCookie(event, name) !== void 0) {
+      return deleteCookie(event, name, opts);
+    }
+  }
+}
+const MAX_TIMEOUT_DELAY = 2147483647;
+function cookieRef(value, delay, shouldWatch) {
+  let timeout;
+  let unsubscribe;
+  let elapsed = 0;
+  const internalRef = shouldWatch ? ref(value) : { value };
+  if (getCurrentScope()) {
+    onScopeDispose(() => {
+      unsubscribe?.();
+      clearTimeout(timeout);
+    });
+  }
+  return customRef((track, trigger) => {
+    if (shouldWatch) {
+      unsubscribe = watch(internalRef, trigger);
+    }
+    function createExpirationTimeout() {
+      elapsed = 0;
+      clearTimeout(timeout);
+      const timeRemaining = delay - elapsed;
+      const timeoutLength = timeRemaining < MAX_TIMEOUT_DELAY ? timeRemaining : MAX_TIMEOUT_DELAY;
+      timeout = setTimeout(() => {
+        elapsed += timeoutLength;
+        if (elapsed < delay) {
+          return createExpirationTimeout();
+        }
+        internalRef.value = void 0;
+        trigger();
+      }, timeoutLength);
+    }
+    return {
+      get() {
+        track();
+        return internalRef.value;
+      },
+      set(newValue) {
+        createExpirationTimeout();
+        internalRef.value = newValue;
+        trigger();
+      }
+    };
+  });
+}

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

@@ -0,0 +1,25 @@
+import type { H3Error } from 'h3';
+import type { Ref } from 'vue';
+import type { NuxtPayload } from '../nuxt.js';
+export declare const NUXT_ERROR_SIGNATURE = "__nuxt_error";
+/** @since 3.0.0 */
+export declare const useError: () => Ref<NuxtPayload["error"]>;
+export interface NuxtError<DataT = unknown> extends H3Error<DataT> {
+    error?: true;
+}
+/** @since 3.0.0 */
+export declare const showError: <DataT = unknown>(error: string | Error | (Partial<NuxtError<DataT>> & {
+    status?: number;
+    statusText?: string;
+})) => NuxtError<DataT>;
+/** @since 3.0.0 */
+export declare const clearError: (options?: {
+    redirect?: string;
+}) => Promise<void>;
+/** @since 3.0.0 */
+export declare const isNuxtError: <DataT = unknown>(error: unknown) => error is NuxtError<DataT>;
+/** @since 3.0.0 */
+export declare const createError: <DataT = unknown>(error: string | Error | (Partial<NuxtError<DataT>> & {
+    status?: number;
+    statusText?: string;
+})) => NuxtError<DataT>;

package/dist/app/composables/error.js

@@ -0,0 +1,39 @@
+import { createError as createH3Error } from "h3";
+import { toRef } from "vue";
+import { useNuxtApp } from "../nuxt.js";
+import { useRouter } from "./router.js";
+export const NUXT_ERROR_SIGNATURE = "__nuxt_error";
+export const useError = /* @__NO_SIDE_EFFECTS__ */ () => toRef(useNuxtApp().payload, "error");
+export const showError = (error) => {
+  const nuxtError = createError(error);
+  try {
+    const error2 = /* @__PURE__ */ useError();
+    if (import.meta.client) {
+      const nuxtApp = useNuxtApp();
+      nuxtApp.hooks.callHook("app:error", nuxtError);
+    }
+    error2.value ||= nuxtError;
+  } catch {
+    throw nuxtError;
+  }
+  return nuxtError;
+};
+export const clearError = async (options = {}) => {
+  const nuxtApp = useNuxtApp();
+  const error = /* @__PURE__ */ useError();
+  nuxtApp.callHook("app:error:cleared", options);
+  if (options.redirect) {
+    await useRouter().replace(options.redirect);
+  }
+  error.value = void 0;
+};
+export const isNuxtError = (error) => !!error && typeof error === "object" && NUXT_ERROR_SIGNATURE in error;
+export const createError = (error) => {
+  const nuxtError = createH3Error(error);
+  Object.defineProperty(nuxtError, NUXT_ERROR_SIGNATURE, {
+    value: true,
+    configurable: false,
+    writable: false
+  });
+  return nuxtError;
+};

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

@@ -0,0 +1,37 @@
+import type { FetchError, FetchOptions, ResponseType as _ResponseType } from 'ofetch';
+import type { NitroFetchRequest, TypedInternalResponse, AvailableRouterMethod as _AvailableRouterMethod } from 'nitropack/types';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { AsyncData, AsyncDataOptions, KeysOf, MultiWatchSources, PickFrom } from './asyncData.js';
+type AvailableRouterMethod<R extends NitroFetchRequest> = _AvailableRouterMethod<R> | Uppercase<_AvailableRouterMethod<R>>;
+export type FetchResult<ReqT extends NitroFetchRequest, M extends AvailableRouterMethod<ReqT>> = TypedInternalResponse<ReqT, unknown, Lowercase<M>>;
+type ComputedOptions<T extends Record<string, any>> = {
+    [K in keyof T]: T[K] extends Function ? T[K] : ComputedOptions<T[K]> | Ref<T[K]> | T[K];
+};
+interface NitroFetchOptions<R extends NitroFetchRequest, M extends AvailableRouterMethod<R> = AvailableRouterMethod<R>, DataT = any> extends FetchOptions<_ResponseType, DataT> {
+    method?: M;
+}
+type ComputedFetchOptions<R extends NitroFetchRequest, M extends AvailableRouterMethod<R>, DataT = any> = ComputedOptions<NitroFetchOptions<R, M, DataT>>;
+export interface UseFetchOptions<ResT, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined, R extends NitroFetchRequest = string & {}, M extends AvailableRouterMethod<R> = AvailableRouterMethod<R>> extends Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'watch'>, Omit<ComputedFetchOptions<R, M, DataT>, 'timeout'> {
+    key?: MaybeRefOrGetter<string>;
+    $fetch?: typeof globalThis.$fetch;
+    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
+ */
+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 {};

package/dist/app/composables/fetch.js

@@ -0,0 +1,123 @@
+import { computed, reactive, toValue, watch } from "vue";
+import { hash } from "ohash";
+import { isPlainObject } from "@vue/shared";
+import { useRequestFetch } from "./ssr.js";
+import { useAsyncData } from "./asyncData.js";
+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",
+    toValue(opts.baseURL)
+  ];
+  for (const _obj of [opts.query || opts.params]) {
+    const obj = toValue(_obj);
+    if (!obj) {
+      continue;
+    }
+    const unwrapped = {};
+    for (const [key, value] of Object.entries(obj)) {
+      unwrapped[toValue(key)] = toValue(value);
+    }
+    segments.push(unwrapped);
+  }
+  if (opts.body) {
+    const value = toValue(opts.body);
+    if (!value) {
+      segments.push(hash(value));
+    } else if (value instanceof ArrayBuffer) {
+      segments.push(hash(Object.fromEntries([...new Uint8Array(value).entries()].map(([k, v]) => [k, v.toString()]))));
+    } else if (value instanceof FormData) {
+      const obj = {};
+      for (const entry of value.entries()) {
+        const [key, val] = entry;
+        obj[key] = val instanceof File ? val.name : val;
+      }
+      segments.push(hash(obj));
+    } else if (isPlainObject(value)) {
+      segments.push(hash(reactive(value)));
+    } else {
+      try {
+        segments.push(hash(value));
+      } catch {
+        console.warn("[useFetch] Failed to hash body", value);
+      }
+    }
+  }
+  return segments;
+}

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

@@ -0,0 +1 @@
+export { injectHead, useHead, useServerHead, useSeoMeta, useServerSeoMeta, useHeadSafe, useServerHeadSafe } from '#unhead/composables';

package/dist/app/composables/head.js

@@ -0,0 +1 @@
+export { injectHead, useHead, useServerHead, useSeoMeta, useServerSeoMeta, useHeadSafe, useServerHeadSafe } from "#unhead/composables";

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

@@ -0,0 +1,9 @@
+import type { NuxtPayload } from '../nuxt.js';
+/**
+ * Allows full control of the hydration cycle to set and receive data from the server.
+ * @param key a unique key to identify the data in the Nuxt payload
+ * @param get a function that returns the value to set the initial data
+ * @param set a function that will receive the data on the client-side
+ * @since 3.0.0
+ */
+export declare const useHydration: <K extends keyof NuxtPayload, T = NuxtPayload[K]>(key: K, get: () => T, set: (value: T) => void) => void;

package/dist/app/composables/hydrate.js

@@ -0,0 +1,14 @@
+import { useNuxtApp } from "../nuxt.js";
+export const useHydration = (key, get, set) => {
+  const nuxtApp = useNuxtApp();
+  if (import.meta.server) {
+    nuxtApp.hooks.hook("app:rendered", () => {
+      nuxtApp.payload[key] = get();
+    });
+  }
+  if (import.meta.client) {
+    nuxtApp.hooks.hook("app:created", () => {
+      set(nuxtApp.payload[key]);
+    });
+  }
+};

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

@@ -0,0 +1,3 @@
+import { useId as _useId } from 'vue';
+/** @deprecated Use `useId` from `vue` */
+export declare const useId: typeof _useId;

package/dist/app/composables/id.js

@@ -0,0 +1,2 @@
+import { useId as _useId } from "vue";
+export const useId = _useId;

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

@@ -0,0 +1,29 @@
+export { defineNuxtComponent } from './component.js';
+export { useAsyncData, useLazyAsyncData, useNuxtData, refreshNuxtData, clearNuxtData } from './asyncData.js';
+export type { AsyncDataOptions, AsyncData, AsyncDataRequestStatus } from './asyncData.js';
+export { useHydration } from './hydrate.js';
+export { callOnce } from './once.js';
+export { useState, clearNuxtState } from './state.js';
+export { clearError, createError, isNuxtError, showError, useError } from './error.js';
+export type { NuxtError } from './error.js';
+export { useFetch, useLazyFetch } from './fetch.js';
+export type { FetchResult, UseFetchOptions } from './fetch.js';
+export { useCookie, refreshCookie } from './cookie.js';
+export type { CookieOptions, CookieRef } from './cookie.js';
+export { onPrehydrate, prerenderRoutes, useRequestHeaders, useRequestEvent, useRequestFetch, setResponseStatus, useResponseHeader } from './ssr.js';
+export { onNuxtReady } from './ready.js';
+export { abortNavigation, addRouteMiddleware, defineNuxtRouteMiddleware, onBeforeRouteLeave, onBeforeRouteUpdate, setPageLayout, navigateTo, useRoute, useRouter } from './router.js';
+export type { AddRouteMiddlewareOptions, RouteMiddleware } from './router.js';
+export { preloadComponents, prefetchComponents, preloadRouteComponents } from './preload.js';
+export { isPrerendered, loadPayload, preloadPayload, definePayloadReducer, definePayloadReviver } from './payload.js';
+export { getAppManifest, getRouteRules } from './manifest.js';
+export type { NuxtAppManifest, NuxtAppManifestMeta } from './manifest.js';
+export type { ReloadNuxtAppOptions } from './chunk.js';
+export { reloadNuxtApp } from './chunk.js';
+export { useRequestURL } from './url.js';
+export { usePreviewMode } from './preview.js';
+export { useId } from './id.js';
+export { useRouteAnnouncer } from './route-announcer.js';
+export type { Politeness } from './route-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

@@ -0,0 +1,21 @@
+export { defineNuxtComponent } from "./component.js";
+export { useAsyncData, useLazyAsyncData, useNuxtData, refreshNuxtData, clearNuxtData } from "./asyncData.js";
+export { useHydration } from "./hydrate.js";
+export { callOnce } from "./once.js";
+export { useState, clearNuxtState } from "./state.js";
+export { clearError, createError, isNuxtError, showError, useError } from "./error.js";
+export { useFetch, useLazyFetch } from "./fetch.js";
+export { useCookie, refreshCookie } from "./cookie.js";
+export { onPrehydrate, prerenderRoutes, useRequestHeaders, useRequestEvent, useRequestFetch, setResponseStatus, useResponseHeader } from "./ssr.js";
+export { onNuxtReady } from "./ready.js";
+export { abortNavigation, addRouteMiddleware, defineNuxtRouteMiddleware, onBeforeRouteLeave, onBeforeRouteUpdate, setPageLayout, navigateTo, useRoute, useRouter } from "./router.js";
+export { preloadComponents, prefetchComponents, preloadRouteComponents } from "./preload.js";
+export { isPrerendered, loadPayload, preloadPayload, definePayloadReducer, definePayloadReviver } from "./payload.js";
+export { getAppManifest, getRouteRules } from "./manifest.js";
+export { reloadNuxtApp } from "./chunk.js";
+export { useRequestURL } from "./url.js";
+export { usePreviewMode } from "./preview.js";
+export { useId } from "./id.js";
+export { useRouteAnnouncer } from "./route-announcer.js";
+export { useRuntimeHook } from "./runtime-hook.js";
+export { injectHead, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta } from "./head.js";

package/dist/app/composables/lazy-hydration.d.ts

@@ -0,0 +1,40 @@
+import type { AsyncComponentLoader, Component, ComponentPublicInstance, DefineComponent } from 'vue';
+type LazyHydrationComponent<T extends Component, Props> = T & DefineComponent<Props, {}, {}, {}, {}, {}, {}, {
+    hydrated: () => void;
+}>;
+export declare function defineLazyHydrationComponent<T extends Component = {
+    new (): ComponentPublicInstance;
+}>(strategy: 'visible', source: AsyncComponentLoader<T>): LazyHydrationComponent<T, {
+    hydrateOnVisible?: IntersectionObserverInit | true;
+}>;
+export declare function defineLazyHydrationComponent<T extends Component = {
+    new (): ComponentPublicInstance;
+}>(strategy: 'idle', source: AsyncComponentLoader<T>): LazyHydrationComponent<T, {
+    hydrateOnIdle?: number | true;
+}>;
+export declare function defineLazyHydrationComponent<T extends Component = {
+    new (): ComponentPublicInstance;
+}>(strategy: 'interaction', source: AsyncComponentLoader<T>): LazyHydrationComponent<T, {
+    hydrateOnInteraction?: keyof HTMLElementEventMap | Array<keyof HTMLElementEventMap>;
+}>;
+export declare function defineLazyHydrationComponent<T extends Component = {
+    new (): ComponentPublicInstance;
+}>(strategy: 'mediaQuery', source: AsyncComponentLoader<T>): LazyHydrationComponent<T, {
+    hydrateOnMediaQuery: string;
+}>;
+export declare function defineLazyHydrationComponent<T extends Component = {
+    new (): ComponentPublicInstance;
+}>(strategy: 'if', source: AsyncComponentLoader<T>): LazyHydrationComponent<T, {
+    hydrateWhen: boolean;
+}>;
+export declare function defineLazyHydrationComponent<T extends Component = {
+    new (): ComponentPublicInstance;
+}>(strategy: 'time', source: AsyncComponentLoader<T>): LazyHydrationComponent<T, {
+    hydrateAfter: number | true;
+}>;
+export declare function defineLazyHydrationComponent<T extends Component = {
+    new (): ComponentPublicInstance;
+}>(strategy: 'never', source: AsyncComponentLoader<T>): LazyHydrationComponent<T, {
+    hydrateNever?: true;
+}>;
+export {};

package/dist/app/composables/lazy-hydration.js

@@ -0,0 +1,2 @@
+export function defineLazyHydrationComponent(_strategy, _source) {
+}

package/dist/app/composables/loading-indicator.d.ts

@@ -0,0 +1,39 @@
+import type { Ref } from 'vue';
+export type LoadingIndicatorOpts = {
+    /** @default 2000 */
+    duration: number;
+    /** @default 200 */
+    throttle: number;
+    /** @default 500 */
+    hideDelay: number;
+    /** @default 400 */
+    resetDelay: number;
+    /**
+     * You can provide a custom function to customize the progress estimation,
+     * which is a function that receives the duration of the loading bar (above)
+     * and the elapsed time. It should return a value between 0 and 100.
+     */
+    estimatedProgress?: (duration: number, elapsed: number) => number;
+};
+export type LoadingIndicator = {
+    _cleanup: () => void;
+    progress: Ref<number>;
+    isLoading: Ref<boolean>;
+    error: Ref<boolean>;
+    start: (opts?: {
+        force?: boolean;
+    }) => void;
+    set: (value: number, opts?: {
+        force?: boolean;
+    }) => void;
+    finish: (opts?: {
+        force?: boolean;
+        error?: boolean;
+    }) => void;
+    clear: () => void;
+};
+/**
+ * composable to handle the loading state of the page
+ * @since 3.9.0
+ */
+export declare function useLoadingIndicator(opts?: Partial<LoadingIndicatorOpts>): Omit<LoadingIndicator, '_cleanup'>;