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

package/dist/app/nuxt.d.ts

@@ -3,7 +3,7 @@ import type { RouteLocationNormalizedLoaded } from 'vue-router';
 import type { Hookable } from 'hookable';
 import type { UseContext } from 'unctx';
 import type { SSRContext, createRenderer } from 'vue-bundle-renderer/runtime';
-import type { EventHandlerRequest, H3Event } from 'h3';
+import type { EventHandlerRequest, H3Event } from '@nuxt/nitro-server/h3';
 import type { RenderResponse } from 'nitropack/types';
 import type { LogObject } from 'consola';
 import type { VueHeadClient } from '@unhead/vue/types';
@@ -15,6 +15,7 @@ import type { AsyncDataExecuteOptions, AsyncDataRequestStatus, DebouncedReturn }
 import type { NuxtAppManifestMeta } from './composables/manifest.js';
 import type { LoadingIndicator } from './composables/loading-indicator.js';
 import type { RouteAnnouncer } from './composables/route-announcer.js';
+import type { NuxtAnnouncer } from './composables/announcer.js';
 import type { AppConfig, AppConfigInput, RuntimeConfig } from 'nuxt/schema';
 export declare function getNuxtAppCtx(id?: string): UseContext<NuxtApp>;
 type HookResult = Promise<void> | void;
@@ -90,25 +91,26 @@ export interface NuxtPayload {
     [key: string]: unknown;
 }
 interface _NuxtApp {
-    vueApp: App<Element>;
-    versions: Record<string, string>;
-    hooks: Hookable<RuntimeNuxtHooks>;
-    hook: _NuxtApp['hooks']['hook'];
-    callHook: _NuxtApp['hooks']['callHook'];
-    runWithContext: <T extends () => any>(fn: T) => ReturnType<T> | Promise<Awaited<ReturnType<T>>>;
+    'vueApp': App<Element>;
+    'versions': Record<string, string>;
+    'hooks': Hookable<RuntimeNuxtHooks>;
+    'hook': _NuxtApp['hooks']['hook'];
+    'callHook': _NuxtApp['hooks']['callHook'];
+    'runWithContext': <T extends () => any>(fn: T) => ReturnType<T> | Promise<Awaited<ReturnType<T>>>;
     [key: string]: unknown;
     /** @internal */
-    _cookies?: Record<string, unknown>;
+    '_cookies'?: Record<string, unknown>;
+    '_cookiesChanged'?: Record<string, boolean>;
     /**
      * The id of the Nuxt application.
      * @internal */
-    _id: string;
+    '_id': string;
     /** @internal */
-    _scope: EffectScope;
+    '_scope': EffectScope;
     /** @internal */
-    _asyncDataPromises: Record<string, Promise<any> | undefined>;
+    '_asyncDataPromises': Record<string, Promise<any> | undefined>;
     /** @internal */
-    _asyncData: Record<string, {
+    '_asyncData': Record<string, {
         data: Ref<unknown>;
         pending: Ref<boolean>;
         error: Ref<Error | undefined>;
@@ -130,47 +132,60 @@ interface _NuxtApp {
         _abortController?: AbortController;
     } | undefined>;
     /** @internal */
-    _loadingIndicator?: LoadingIndicator;
+    '_state': Record<string, {
+        /** @internal */
+        _default: () => unknown;
+    } | undefined>;
+    /** @internal */
+    '_loadingIndicator'?: LoadingIndicator;
     /** @internal */
-    _loadingIndicatorDeps?: number;
+    '_loadingIndicatorDeps'?: number;
     /** @internal */
-    _middleware: {
+    '_middleware': {
         global: RouteMiddleware[];
         named: Record<string, RouteMiddleware>;
     };
     /** @internal */
-    _processingMiddleware?: string | boolean;
+    '_processingMiddleware'?: string | boolean;
     /** @internal */
-    _once: {
+    '_once': {
         [key: string]: Promise<any>;
     };
     /** @internal */
-    _observer?: {
+    '_observer'?: {
         observe: (element: Element, callback: () => void) => () => void;
     };
     /** @internal */
-    _appConfig: AppConfig;
+    '_appConfig': AppConfig;
     /** @internal */
-    _route: RouteLocationNormalizedLoaded & {
+    '_route': RouteLocationNormalizedLoaded & {
         sync?: () => void;
     };
     /** @internal */
-    _islandPromises?: Record<string, Promise<any>>;
+    '_islandPromises'?: Record<string, Promise<any>>;
+    /** @internal */
+    '_payloadRevivers': Record<string, (data: any) => any>;
+    /** @internal */
+    '_routeAnnouncer'?: RouteAnnouncer;
+    /** @internal */
+    '_routeAnnouncerDeps'?: number;
+    /** @internal */
+    '~transitionPromise'?: Promise<void>;
     /** @internal */
-    _payloadRevivers: Record<string, (data: any) => any>;
+    '~transitionFinish'?: () => void;
     /** @internal */
-    _routeAnnouncer?: RouteAnnouncer;
+    '_announcer'?: NuxtAnnouncer;
     /** @internal */
-    _routeAnnouncerDeps?: number;
-    $config: RuntimeConfig;
-    isHydrating?: boolean;
-    deferHydration: () => () => void | Promise<void>;
-    ssrContext?: NuxtSSRContext;
-    payload: NuxtPayload;
-    static: {
+    '_announcerDeps'?: number;
+    '$config': RuntimeConfig;
+    'isHydrating'?: boolean;
+    'deferHydration': () => () => void | Promise<void>;
+    'ssrContext'?: NuxtSSRContext;
+    'payload': NuxtPayload;
+    'static': {
         data: Record<string, any>;
     };
-    provide: (name: string, value: any) => void;
+    'provide': (name: string, value: any) => void;
 }
 export interface NuxtApp extends _NuxtApp {
 }

package/dist/app/nuxt.js

@@ -1,7 +1,7 @@
 import { effectScope, getCurrentInstance, getCurrentScope, hasInjectionContext, reactive, shallowReactive } from "vue";
 import { createHooks } from "hookable";
 import { getContext } from "unctx";
-import { appId, chunkErrorEvent, multiApp } from "#build/nuxt.config.mjs";
+import { appId, asyncCallHook, chunkErrorEvent, multiApp } from "#build/nuxt.config.mjs";
 export function getNuxtAppCtx(id = appId || "nuxt-app") {
   return getContext(id, {
     asyncContext: !!__NUXT_ASYNC_CONTEXT__ && import.meta.server
@@ -60,6 +60,7 @@ export function createNuxtApp(options) {
     },
     _asyncDataPromises: {},
     _asyncData: shallowReactive({}),
+    _state: shallowReactive({}),
     _payloadRevivers: {},
     ...options
   };
@@ -99,7 +100,10 @@ export function createNuxtApp(options) {
         await nuxtApp.runWithContext(() => hook(...args));
       }
     };
-    nuxtApp.hooks.callHook = (name, ...args) => nuxtApp.hooks.callHookWith(contextCaller, name, ...args);
+    nuxtApp.hooks.callHook = (name, ...args) => nuxtApp.hooks.callHookWith(contextCaller, name, args);
+  } else if (asyncCallHook) {
+    const _callHook = nuxtApp.hooks.callHook;
+    nuxtApp.hooks.callHook = (name, ...args) => Promise.resolve().then(() => _callHook(name, ...args));
   }
   nuxtApp.callHook = nuxtApp.hooks.callHook;
   nuxtApp.provide = (name, value) => {

package/dist/app/plugins/restore-state.client.js

@@ -1,4 +1,3 @@
-import destr from "destr";
 import { defineNuxtPlugin, useNuxtApp } from "../nuxt.js";
 export default defineNuxtPlugin({
   name: "nuxt:restore-state",
@@ -9,7 +8,7 @@ export default defineNuxtPlugin({
         const state = sessionStorage.getItem("nuxt:reload:state");
         if (state) {
           sessionStorage.removeItem("nuxt:reload:state");
-          Object.assign(nuxtApp.payload.state, destr(state)?.state);
+          Object.assign(nuxtApp.payload.state, JSON.parse(state)?.state);
         }
       } catch {
       }

package/dist/app/plugins/revive-payload.client.js

@@ -1,13 +1,19 @@
 import { reactive, ref, shallowReactive, shallowRef } from "vue";
-import destr from "destr";
 import { definePayloadReviver, getNuxtClientPayload } from "../composables/payload.js";
 import { createError } from "../composables/error.js";
 import { defineNuxtPlugin, useNuxtApp } from "../nuxt.js";
 import { componentIslands } from "#build/nuxt.config.mjs";
+function parseRevivedData(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return data;
+  }
+}
 const revivers = [
   ["NuxtError", (data) => createError(data)],
-  ["EmptyShallowRef", (data) => shallowRef(data === "_" ? void 0 : data === "0n" ? BigInt(0) : destr(data))],
-  ["EmptyRef", (data) => ref(data === "_" ? void 0 : data === "0n" ? BigInt(0) : destr(data))],
+  ["EmptyShallowRef", (data) => shallowRef(data === "_" ? void 0 : data === "0n" ? BigInt(0) : parseRevivedData(data))],
+  ["EmptyRef", (data) => ref(data === "_" ? void 0 : data === "0n" ? BigInt(0) : parseRevivedData(data))],
   ["ShallowRef", (data) => shallowRef(data)],
   ["ShallowReactive", (data) => shallowReactive(data)],
   ["Ref", (data) => ref(data)],

package/dist/app/plugins/router.js

@@ -1,6 +1,6 @@
 import { computed, defineComponent, h, isReadonly, reactive } from "vue";
 import { isEqual, joinURL, parseQuery, stringifyParsedURL, stringifyQuery, withoutBase } from "ufo";
-import { createError } from "h3";
+import { createError } from "@nuxt/nitro-server/h3";
 import { defineNuxtPlugin, useRuntimeConfig } from "../nuxt.js";
 import { getRouteRules } from "../composables/manifest.js";
 import { clearError, showError } from "../composables/error.js";
@@ -57,7 +57,7 @@ export default defineNuxtPlugin({
             return;
           }
           if (typeof result === "string" && result.length) {
-            return handleNavigation(result, true);
+            return await handleNavigation(result, true);
           }
         }
         for (const handler of hooks["resolve:before"]) {

package/dist/app/plugins/view-transitions.client.js

@@ -23,27 +23,62 @@ export default defineNuxtPlugin((nuxtApp) => {
     }
   });
   const router = useRouter();
+  const normalizeViewTransitionOptions = (value) => {
+    if (typeof value === "boolean" || value === "always") {
+      return { enabled: value };
+    }
+    if (value && typeof value === "object") {
+      return value;
+    }
+    return {};
+  };
   router.beforeResolve(async (to, from) => {
-    const viewTransitionMode = to.meta.viewTransition ?? defaultViewTransition;
+    if (to.matched.length === 0) {
+      return;
+    }
+    const toViewTransitionOptions = normalizeViewTransitionOptions(to.meta.viewTransition);
+    const fromViewTransitionOptions = normalizeViewTransitionOptions(from.meta.viewTransition);
+    const viewTransitionMode = toViewTransitionOptions.enabled ?? defaultViewTransition.enabled;
     const prefersReducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
     const prefersNoTransition = prefersReducedMotion && viewTransitionMode !== "always";
     if (viewTransitionMode === false || prefersNoTransition || hasUAVisualTransition || !isChangingPage(to, from)) {
       return;
     }
+    const resolveViewTransitionTypes = (types) => {
+      return types ? typeof types === "function" ? types(to, from) : types : void 0;
+    };
+    const viewTransitionBaseTypes = resolveViewTransitionTypes(toViewTransitionOptions.types) ?? resolveViewTransitionTypes(defaultViewTransition.types) ?? [];
+    const viewTransitionFromTypes = resolveViewTransitionTypes(fromViewTransitionOptions.fromTypes) ?? [];
+    const viewTransitionToTypes = resolveViewTransitionTypes(toViewTransitionOptions.toTypes) ?? [];
+    const allTypes = [
+      ...viewTransitionBaseTypes,
+      ...viewTransitionFromTypes,
+      ...viewTransitionToTypes
+    ];
     const promise = new Promise((resolve, reject) => {
       finishTransition = resolve;
       abortTransition = reject;
     });
     let changeRoute;
     const ready = new Promise((resolve) => changeRoute = resolve);
-    transition = document.startViewTransition(() => {
+    const update = () => {
       changeRoute();
       return promise;
-    });
-    transition.finished.then(resetTransitionState);
+    };
+    transition = allTypes.length > 0 ? document.startViewTransition({ update, types: allTypes }) : document.startViewTransition(update);
+    transition.finished.catch(() => {
+    }).finally(resetTransitionState);
     await nuxtApp.callHook("page:view-transition:start", transition);
     return ready;
   });
+  router.onError(() => {
+    abortTransition?.();
+    resetTransitionState();
+  });
+  nuxtApp.hook("app:error", () => {
+    abortTransition?.();
+    resetTransitionState();
+  });
   nuxtApp.hook("vue:error", () => {
     abortTransition?.();
     resetTransitionState();

package/dist/compiler/runtime/index.d.ts

@@ -0,0 +1,14 @@
+export interface ObjectFactory<T extends Function> {
+    /**
+     * The name of the factory function.
+     * @example 'createUseFetch'
+     */
+    name: string;
+    factory: T;
+}
+/**
+ * Define a factory for a function that should be registered for automatic key injection.
+ * @since 4.2.0
+ * @param factory
+ */
+export declare function defineKeyedFunctionFactory<T extends Function>(factory: ObjectFactory<T>): T;

package/dist/compiler/runtime/index.js

@@ -0,0 +1,14 @@
+export function defineKeyedFunctionFactory(factory) {
+  const placeholder = function() {
+    if (import.meta.dev) {
+      throw new Error(
+        `[nuxt:compiler] \`${factory.name}\` is a compiler macro that is only usable inside the directories scanned by the Nuxt compiler as an exported function and imported statically. Learn more: \`https://nuxt.com/docs/guide/going-further/compiler\``
+      );
+    }
+    throw new Error(`[nuxt] \`${factory.name}\` is a compiler macro and cannot be called at runtime.`);
+  };
+  return Object.defineProperty(placeholder, "__nuxt_factory", {
+    enumerable: false,
+    get: () => factory.factory
+  });
+}