@depup/nuxt 4.2.2-depup.0

package/dist/pages/runtime/app.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/pages/runtime/app.vue

@@ -0,0 +1,6 @@
+<template>
+  <NuxtLayout>
+    <NuxtRouteAnnouncer />
+    <NuxtPage />
+  </NuxtLayout>
+</template>

package/dist/pages/runtime/app.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/pages/runtime/component-stub.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/pages/runtime/component-stub.js

@@ -0,0 +1 @@
+export default {};

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

@@ -0,0 +1,58 @@
+import type { KeepAliveProps, TransitionProps, UnwrapRef } from 'vue';
+import type { RouteLocationNormalized, RouteLocationNormalizedLoaded, RouteRecordRaw, RouteRecordRedirectOption } from 'vue-router';
+import type { NitroRouteConfig } from 'nitropack/types';
+import type { NuxtError } from 'nuxt/app';
+export interface PageMeta {
+    [key: string]: unknown;
+    /**
+     * Validate whether a given route can validly be rendered with this page.
+     *
+     * Return true if it is valid, or false if not. If another match can't be found,
+     * this will mean a 404. You can also directly return an object with
+     * statusCode/statusMessage to respond immediately with an error (other matches
+     * will not be checked).
+     */
+    validate?: (route: RouteLocationNormalized) => boolean | Partial<NuxtError> | Promise<boolean | Partial<NuxtError>>;
+    /**
+     * Where to redirect if the route is directly matched. The redirection happens
+     * before any navigation guard and triggers a new navigation with the new
+     * target location.
+     */
+    redirect?: RouteRecordRedirectOption;
+    /**
+     * Aliases for the record. Allows defining extra paths that will behave like a
+     * copy of the record. Allows having paths shorthands like `/users/:id` and
+     * `/u/:id`. All `alias` and `path` values must share the same params.
+     */
+    alias?: string | string[];
+    pageTransition?: boolean | TransitionProps;
+    layoutTransition?: boolean | TransitionProps;
+    key?: false | string | ((route: RouteLocationNormalizedLoaded) => string);
+    keepalive?: boolean | KeepAliveProps;
+    /** You may define a name for this page's route. */
+    name?: string;
+    /** You may define a path matcher, if you have a more complex pattern than can be expressed with the file name. */
+    path?: string;
+    /**
+     * Allows accessing the route `params` as props passed to the page component.
+     * @see https://router.vuejs.org/guide/essentials/passing-props
+     */
+    props?: RouteRecordRaw['props'];
+    /** Set to `false` to avoid scrolling to top on page navigations */
+    scrollToTop?: boolean | ((to: RouteLocationNormalizedLoaded, from: RouteLocationNormalizedLoaded) => boolean);
+}
+declare module 'vue-router' {
+    interface RouteMeta extends UnwrapRef<PageMeta> {
+    }
+}
+export declare const definePageMeta: (meta: PageMeta) => void;
+/**
+ * You can define route rules for the current page. Matching route rules will be created, based on the page's _path_.
+ *
+ * For example, a rule defined in `~/pages/foo/bar.vue` will be applied to `/foo/bar` requests. A rule in
+ * `~/pages/foo/[id].vue` will be applied to `/foo/**` requests.
+ *
+ * For more control, such as if you are using a custom `path` or `alias` set in the page's `definePageMeta`, you
+ * should set `routeRules` directly within your `nuxt.config`.
+ */
+export declare const defineRouteRules: (rules: NitroRouteConfig) => void;

package/dist/pages/runtime/composables.js

@@ -0,0 +1,24 @@
+import { getCurrentInstance } from "vue";
+import { useRoute } from "vue-router";
+import { useNuxtApp } from "#app/nuxt";
+const warnRuntimeUsage = (method) => {
+  console.warn(
+    `${method}() is a compiler-hint helper that is only usable inside the script block of a single file component which is also a page. Its arguments should be compiled away and passing it at runtime has no effect.`
+  );
+};
+export const definePageMeta = (meta) => {
+  if (import.meta.dev) {
+    const component = getCurrentInstance()?.type;
+    try {
+      const isRouteComponent = component && useRoute().matched.some((p) => Object.values(p.components || {}).includes(component));
+      const isRenderingServerPage = import.meta.server && useNuxtApp().ssrContext?.islandContext;
+      if (isRouteComponent || isRenderingServerPage || component?.__clientOnlyPage) {
+        return;
+      }
+    } catch {
+    }
+    warnRuntimeUsage("definePageMeta");
+  }
+};
+export const defineRouteRules = /* @__NO_SIDE_EFFECTS__ */ (rules) => {
+};

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

@@ -0,0 +1,3 @@
+export { definePageMeta, defineRouteRules } from './composables.js';
+export type { PageMeta } from './composables.js';
+export type { NuxtPageProps } from './page.js';

package/dist/pages/runtime/index.js

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

package/dist/pages/runtime/page-placeholder.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/pages/runtime/page-placeholder.js

@@ -0,0 +1,11 @@
+import { defineComponent } from "vue";
+import { devPagesDir } from "#build/nuxt.config.mjs";
+export default defineComponent({
+  name: "NuxtPage",
+  setup(_, props) {
+    if (import.meta.dev) {
+      console.warn(`Create a Vue component in the \`${devPagesDir}/\` directory to enable \`<NuxtPage>\``);
+    }
+    return () => props.slots.default?.();
+  }
+});

package/dist/pages/runtime/page.d.ts

@@ -0,0 +1,30 @@
+import type { AllowedComponentProps, ComponentCustomProps, ComponentPublicInstance, KeepAliveProps, TransitionProps, VNode, VNodeProps } from 'vue';
+import type { RouteLocationNormalizedLoaded, RouterViewProps } from 'vue-router';
+import type { RouterViewSlotProps } from './utils.js';
+export interface NuxtPageProps extends RouterViewProps {
+    /**
+     * Define global transitions for all pages rendered with the `NuxtPage` component.
+     */
+    transition?: boolean | TransitionProps;
+    /**
+     * Control state preservation of pages rendered with the `NuxtPage` component.
+     */
+    keepalive?: boolean | KeepAliveProps;
+    /**
+     * Control when the `NuxtPage` component is re-rendered.
+     */
+    pageKey?: string | ((route: RouteLocationNormalizedLoaded) => string);
+}
+declare const _default: {
+    new (): {
+        $props: AllowedComponentProps & ComponentCustomProps & VNodeProps & NuxtPageProps;
+        $slots: {
+            default?: (routeProps: RouterViewSlotProps) => VNode[];
+        };
+        /**
+         * Reference to the page component instance
+         */
+        pageRef: Element | ComponentPublicInstance | null;
+    };
+};
+export default _default;

package/dist/pages/runtime/page.js

@@ -0,0 +1,212 @@
+import { Fragment, Suspense, defineComponent, h, inject, nextTick, onBeforeUnmount, ref, watch } from "vue";
+import { RouterView } from "vue-router";
+import { defu } from "defu";
+import { generateRouteKey, toArray, wrapInKeepAlive } from "./utils.js";
+import { RouteProvider, defineRouteProvider } from "#app/components/route-provider";
+import { useNuxtApp } from "#app/nuxt";
+import { useRouter } from "#app/composables/router";
+import { _wrapInTransition } from "#app/components/utils";
+import { LayoutMetaSymbol, PageRouteSymbol } from "#app/components/injections";
+import { appKeepalive as defaultKeepaliveConfig, appPageTransition as defaultPageTransition } from "#build/nuxt.config.mjs";
+const _routeProviders = import.meta.dev ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new WeakMap();
+export default defineComponent({
+  name: "NuxtPage",
+  inheritAttrs: false,
+  props: {
+    name: {
+      type: String
+    },
+    transition: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    keepalive: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    route: {
+      type: Object
+    },
+    pageKey: {
+      type: [Function, String],
+      default: null
+    }
+  },
+  setup(props, { attrs, slots, expose }) {
+    const nuxtApp = useNuxtApp();
+    const pageRef = ref();
+    const forkRoute = inject(PageRouteSymbol, null);
+    let previousPageKey;
+    expose({ pageRef });
+    const _layoutMeta = inject(LayoutMetaSymbol, null);
+    let vnode;
+    const done = nuxtApp.deferHydration();
+    if (import.meta.client && nuxtApp.isHydrating) {
+      const removeErrorHook = nuxtApp.hooks.hookOnce("app:error", done);
+      useRouter().beforeEach(removeErrorHook);
+    }
+    if (import.meta.client && props.pageKey) {
+      watch(() => props.pageKey, (next, prev) => {
+        if (next !== prev) {
+          nuxtApp.callHook("page:loading:start");
+        }
+      });
+    }
+    if (import.meta.dev) {
+      nuxtApp._isNuxtPageUsed = true;
+    }
+    let pageLoadingEndHookAlreadyCalled = false;
+    if (import.meta.client) {
+      const unsub = useRouter().beforeResolve(() => {
+        pageLoadingEndHookAlreadyCalled = false;
+      });
+      onBeforeUnmount(() => {
+        unsub();
+      });
+    }
+    return () => {
+      return h(RouterView, { name: props.name, route: props.route, ...attrs }, {
+        default: import.meta.server ? (routeProps) => {
+          return h(Suspense, { suspensible: true }, {
+            default() {
+              return h(RouteProvider, {
+                vnode: slots.default ? normalizeSlot(slots.default, routeProps) : routeProps.Component,
+                route: routeProps.route,
+                vnodeRef: pageRef
+              });
+            }
+          });
+        } : (routeProps) => {
+          const isRenderingNewRouteInOldFork = haveParentRoutesRendered(forkRoute, routeProps.route, routeProps.Component);
+          const hasSameChildren = forkRoute && forkRoute.matched.length === routeProps.route.matched.length;
+          if (!routeProps.Component) {
+            if (vnode && !hasSameChildren) {
+              return vnode;
+            }
+            done();
+            return;
+          }
+          if (vnode && _layoutMeta && !_layoutMeta.isCurrent(routeProps.route)) {
+            return vnode;
+          }
+          if (isRenderingNewRouteInOldFork && forkRoute && (!_layoutMeta || _layoutMeta?.isCurrent(forkRoute))) {
+            if (hasSameChildren) {
+              return vnode;
+            }
+            return null;
+          }
+          const key = generateRouteKey(routeProps, props.pageKey);
+          const willRenderAnotherChild = hasChildrenRoutes(forkRoute, routeProps.route, routeProps.Component);
+          if (!nuxtApp.isHydrating && previousPageKey === key && !willRenderAnotherChild) {
+            nextTick(() => {
+              pageLoadingEndHookAlreadyCalled = true;
+              nuxtApp.callHook("page:loading:end");
+            });
+          }
+          previousPageKey = key;
+          const hasTransition = !!(props.transition ?? routeProps.route.meta.pageTransition ?? defaultPageTransition);
+          const transitionProps = hasTransition && _mergeTransitionProps([
+            props.transition,
+            routeProps.route.meta.pageTransition,
+            defaultPageTransition,
+            {
+              onAfterLeave() {
+                delete nuxtApp._runningTransition;
+                nuxtApp.callHook("page:transition:finish", routeProps.Component);
+              }
+            }
+          ]);
+          const keepaliveConfig = props.keepalive ?? routeProps.route.meta.keepalive ?? defaultKeepaliveConfig;
+          vnode = _wrapInTransition(
+            hasTransition && transitionProps,
+            wrapInKeepAlive(
+              keepaliveConfig,
+              h(Suspense, {
+                suspensible: true,
+                onPending: () => {
+                  if (hasTransition) {
+                    nuxtApp._runningTransition = true;
+                  }
+                  nuxtApp.callHook("page:start", routeProps.Component);
+                },
+                onResolve: async () => {
+                  await nextTick();
+                  try {
+                    nuxtApp._route.sync?.();
+                    await nuxtApp.callHook("page:finish", routeProps.Component);
+                    delete nuxtApp._runningTransition;
+                    if (!pageLoadingEndHookAlreadyCalled && !willRenderAnotherChild) {
+                      pageLoadingEndHookAlreadyCalled = true;
+                      await nuxtApp.callHook("page:loading:end");
+                    }
+                  } finally {
+                    done();
+                  }
+                }
+              }, {
+                default: () => {
+                  const routeProviderProps = {
+                    key: key || void 0,
+                    vnode: slots.default ? normalizeSlot(slots.default, routeProps) : routeProps.Component,
+                    route: routeProps.route,
+                    renderKey: key || void 0,
+                    trackRootNodes: hasTransition,
+                    vnodeRef: pageRef
+                  };
+                  if (!keepaliveConfig) {
+                    return h(RouteProvider, routeProviderProps);
+                  }
+                  const routerComponentType = routeProps.Component.type;
+                  const routeProviderKey = import.meta.dev ? routerComponentType.name || routerComponentType.__name : routerComponentType;
+                  let PageRouteProvider = _routeProviders.get(routeProviderKey);
+                  if (!PageRouteProvider) {
+                    PageRouteProvider = defineRouteProvider(routerComponentType.name || routerComponentType.__name);
+                    _routeProviders.set(routeProviderKey, PageRouteProvider);
+                  }
+                  return h(PageRouteProvider, routeProviderProps);
+                }
+              })
+            )
+          ).default();
+          return vnode;
+        }
+      });
+    };
+  }
+});
+function _mergeTransitionProps(routeProps) {
+  const _props = [];
+  for (const prop of routeProps) {
+    if (!prop) {
+      continue;
+    }
+    _props.push({
+      ...prop,
+      onAfterLeave: prop.onAfterLeave ? toArray(prop.onAfterLeave) : void 0
+    });
+  }
+  return defu(..._props);
+}
+function haveParentRoutesRendered(fork, newRoute, Component) {
+  if (!fork) {
+    return false;
+  }
+  const index = newRoute.matched.findIndex((m) => m.components?.default === Component?.type);
+  if (!index || index === -1) {
+    return false;
+  }
+  return newRoute.matched.slice(0, index).some(
+    (c, i) => c.components?.default !== fork.matched[i]?.components?.default
+  ) || Component && generateRouteKey({ route: newRoute, Component }) !== generateRouteKey({ route: fork, Component });
+}
+function hasChildrenRoutes(fork, newRoute, Component) {
+  if (!fork) {
+    return false;
+  }
+  const index = newRoute.matched.findIndex((m) => m.components?.default === Component?.type);
+  return index < newRoute.matched.length - 1;
+}
+function normalizeSlot(slot, data) {
+  const slotContent = slot(data);
+  return slotContent.length === 1 ? h(slotContent[0]) : h(Fragment, void 0, slotContent);
+}

package/dist/pages/runtime/plugins/check-if-page-unused.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/pages/runtime/plugins/check-if-page-unused.js

@@ -0,0 +1,29 @@
+import { nextTick } from "vue";
+import { defineNuxtPlugin } from "#app/nuxt";
+import { onNuxtReady } from "#app/composables/ready";
+import { useError } from "#app/composables/error";
+export default defineNuxtPlugin({
+  name: "nuxt:checkIfPageUnused",
+  setup(nuxtApp) {
+    const error = useError();
+    function checkIfPageUnused() {
+      if (!error.value && !nuxtApp._isNuxtPageUsed) {
+        console.warn(
+          "[nuxt] Your project has pages but the `<NuxtPage />` component has not been used. You might be using the `<RouterView />` component instead, which will not work correctly in Nuxt. You can set `pages: false` in `nuxt.config` if you do not wish to use the Nuxt `vue-router` integration."
+        );
+      }
+    }
+    if (import.meta.server) {
+      nuxtApp.hook("app:rendered", ({ renderResult }) => {
+        if (renderResult?.html) {
+          nextTick(checkIfPageUnused);
+        }
+      });
+    } else {
+      onNuxtReady(checkIfPageUnused);
+    }
+  },
+  env: {
+    islands: false
+  }
+});

package/dist/pages/runtime/plugins/prefetch.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/pages/runtime/plugins/prefetch.client.js

@@ -0,0 +1,41 @@
+import { hasProtocol } from "ufo";
+import { toArray } from "../utils.js";
+import { defineNuxtPlugin } from "#app/nuxt";
+import { useRouter } from "#app/composables/router";
+import layouts from "#build/layouts";
+import { namedMiddleware } from "#build/middleware";
+import { _loadAsyncComponent } from "#app/composables/preload";
+export default defineNuxtPlugin({
+  name: "nuxt:prefetch",
+  setup(nuxtApp) {
+    const router = useRouter();
+    nuxtApp.hooks.hook("app:mounted", () => {
+      router.beforeEach(async (to) => {
+        const layout = to?.meta?.layout;
+        if (layout && typeof layouts[layout] === "function") {
+          await layouts[layout]();
+        }
+      });
+    });
+    nuxtApp.hooks.hook("link:prefetch", (url) => {
+      if (hasProtocol(url)) {
+        return;
+      }
+      const route = router.resolve(url);
+      if (!route) {
+        return;
+      }
+      const layout = route.meta.layout;
+      let middleware = toArray(route.meta.middleware);
+      middleware = middleware.filter((m) => typeof m === "string");
+      for (const name of middleware) {
+        if (typeof namedMiddleware[name] === "function") {
+          namedMiddleware[name]();
+        }
+      }
+      if (typeof layout === "string" && layout in layouts) {
+        _loadAsyncComponent(layouts[layout]);
+      }
+    });
+  }
+});

package/dist/pages/runtime/plugins/prerender.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/pages/runtime/plugins/prerender.server.js

@@ -0,0 +1,47 @@
+import { joinURL } from "ufo";
+import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
+import defu from "defu";
+import { defineNuxtPlugin, useRuntimeConfig } from "#app/nuxt";
+import { prerenderRoutes } from "#app/composables/ssr";
+import _routes from "#build/routes";
+import routerOptions, { hashMode } from "#build/router.options";
+import { crawlLinks } from "#build/nuxt.config.mjs";
+let routes;
+let _routeRulesMatcher = void 0;
+export default defineNuxtPlugin(async () => {
+  if (!import.meta.server || !import.meta.prerender || hashMode) {
+    return;
+  }
+  if (routes && !routes.length) {
+    return;
+  }
+  const routeRules = useRuntimeConfig().nitro.routeRules;
+  if (!crawlLinks && routeRules && Object.values(routeRules).some((r) => r.prerender)) {
+    _routeRulesMatcher = toRouteMatcher(createRadixRouter({ routes: routeRules }));
+  }
+  routes ||= Array.from(processRoutes(await routerOptions.routes?.(_routes) ?? _routes));
+  const batch = routes.splice(0, 10);
+  prerenderRoutes(batch);
+});
+const OPTIONAL_PARAM_RE = /^\/?:.*(?:\?|\(\.\*\)\*)$/;
+function shouldPrerender(path) {
+  return !_routeRulesMatcher || defu({}, ..._routeRulesMatcher.matchAll(path).reverse()).prerender;
+}
+function processRoutes(routes2, currentPath = "/", routesToPrerender = /* @__PURE__ */ new Set()) {
+  for (const route of routes2) {
+    if (OPTIONAL_PARAM_RE.test(route.path) && !route.children?.length && shouldPrerender(currentPath)) {
+      routesToPrerender.add(currentPath);
+    }
+    if (route.path.includes(":")) {
+      continue;
+    }
+    const fullPath = joinURL(currentPath, route.path);
+    if (shouldPrerender(fullPath)) {
+      routesToPrerender.add(fullPath);
+    }
+    if (route.children) {
+      processRoutes(route.children, fullPath, routesToPrerender);
+    }
+  }
+  return routesToPrerender;
+}

package/dist/pages/runtime/plugins/router.d.ts

@@ -0,0 +1,6 @@
+import type { Router } from 'vue-router';
+import type { Plugin } from 'nuxt/app';
+declare const plugin: Plugin<{
+    router: Router;
+}>;
+export default plugin;