@depup/nuxt 4.2.2-depup.0

package/dist/pages/runtime/plugins/router.js

@@ -0,0 +1,236 @@
+import { isReadonly, reactive, shallowReactive, shallowRef } from "vue";
+import { START_LOCATION, createMemoryHistory, createRouter, createWebHashHistory, createWebHistory } from "vue-router";
+import { isSamePath, withoutBase } from "ufo";
+import { toArray } from "../utils.js";
+import { getRouteRules } from "#app/composables/manifest";
+import { defineNuxtPlugin, useRuntimeConfig } from "#app/nuxt";
+import { clearError, createError, isNuxtError, showError, useError } from "#app/composables/error";
+import { navigateTo } from "#app/composables/router";
+import { appManifest as isAppManifestEnabled } from "#build/nuxt.config.mjs";
+import _routes, { handleHotUpdate } from "#build/routes";
+import routerOptions, { hashMode } from "#build/router.options";
+import { globalMiddleware, namedMiddleware } from "#build/middleware";
+function createCurrentLocation(base, location, renderedPath) {
+  const { pathname, search, hash } = location;
+  const hashPos = base.indexOf("#");
+  if (hashPos > -1) {
+    const slicePos = hash.includes(base.slice(hashPos)) ? base.slice(hashPos).length : 1;
+    let pathFromHash = hash.slice(slicePos);
+    if (pathFromHash[0] !== "/") {
+      pathFromHash = "/" + pathFromHash;
+    }
+    return withoutBase(pathFromHash, "");
+  }
+  const displayedPath = withoutBase(pathname, base);
+  const path = !renderedPath || isSamePath(displayedPath, renderedPath) ? displayedPath : renderedPath;
+  return path + (path.includes("?") ? "" : search) + hash;
+}
+const plugin = defineNuxtPlugin({
+  name: "nuxt:router",
+  enforce: "pre",
+  async setup(nuxtApp) {
+    let routerBase = useRuntimeConfig().app.baseURL;
+    if (hashMode && !routerBase.includes("#")) {
+      routerBase += "#";
+    }
+    const history = routerOptions.history?.(routerBase) ?? (import.meta.client ? hashMode ? createWebHashHistory(routerBase) : createWebHistory(routerBase) : createMemoryHistory(routerBase));
+    const routes = routerOptions.routes ? await routerOptions.routes(_routes) ?? _routes : _routes;
+    let startPosition;
+    const router = createRouter({
+      ...routerOptions,
+      scrollBehavior: (to, from, savedPosition) => {
+        if (from === START_LOCATION) {
+          startPosition = savedPosition;
+          return;
+        }
+        if (routerOptions.scrollBehavior) {
+          router.options.scrollBehavior = routerOptions.scrollBehavior;
+          if ("scrollRestoration" in window.history) {
+            const unsub = router.beforeEach(() => {
+              unsub();
+              window.history.scrollRestoration = "manual";
+            });
+          }
+          return routerOptions.scrollBehavior(to, START_LOCATION, startPosition || savedPosition);
+        }
+      },
+      history,
+      routes
+    });
+    if (import.meta.hot) {
+      handleHotUpdate(router, routerOptions.routes ? routerOptions.routes : (routes2) => routes2);
+    }
+    if (import.meta.client && "scrollRestoration" in window.history) {
+      window.history.scrollRestoration = "auto";
+    }
+    nuxtApp.vueApp.use(router);
+    const previousRoute = shallowRef(router.currentRoute.value);
+    router.afterEach((_to, from) => {
+      previousRoute.value = from;
+    });
+    Object.defineProperty(nuxtApp.vueApp.config.globalProperties, "previousRoute", {
+      get: () => previousRoute.value
+    });
+    const initialURL = import.meta.server ? nuxtApp.ssrContext.url : createCurrentLocation(routerBase, window.location, nuxtApp.payload.path);
+    const _route = shallowRef(router.currentRoute.value);
+    const syncCurrentRoute = () => {
+      _route.value = router.currentRoute.value;
+    };
+    router.afterEach((to, from) => {
+      if (to.matched.at(-1)?.components?.default === from.matched.at(-1)?.components?.default) {
+        syncCurrentRoute();
+      }
+    });
+    const route = { sync: syncCurrentRoute };
+    for (const key in _route.value) {
+      Object.defineProperty(route, key, {
+        get: () => _route.value[key],
+        enumerable: true
+      });
+    }
+    nuxtApp._route = shallowReactive(route);
+    nuxtApp._middleware ||= {
+      global: [],
+      named: {}
+    };
+    const error = useError();
+    if (import.meta.client || !nuxtApp.ssrContext?.islandContext) {
+      router.afterEach(async (to, _from, failure) => {
+        delete nuxtApp._processingMiddleware;
+        if (import.meta.client && !nuxtApp.isHydrating && error.value) {
+          await nuxtApp.runWithContext(clearError);
+        }
+        if (failure) {
+          await nuxtApp.callHook("page:loading:end");
+        }
+        if (import.meta.server && failure?.type === 4) {
+          return;
+        }
+        if (import.meta.server && to.redirectedFrom && to.fullPath !== initialURL) {
+          await nuxtApp.runWithContext(() => navigateTo(to.fullPath || "/"));
+        }
+      });
+    }
+    try {
+      if (import.meta.server) {
+        await router.push(initialURL);
+      }
+      await router.isReady();
+    } catch (error2) {
+      await nuxtApp.runWithContext(() => showError(error2));
+    }
+    const resolvedInitialRoute = import.meta.client && initialURL !== router.currentRoute.value.fullPath ? router.resolve(initialURL) : router.currentRoute.value;
+    syncCurrentRoute();
+    if (import.meta.server && nuxtApp.ssrContext?.islandContext) {
+      return { provide: { router } };
+    }
+    const initialLayout = nuxtApp.payload.state._layout;
+    router.beforeEach(async (to, from) => {
+      await nuxtApp.callHook("page:loading:start");
+      to.meta = reactive(to.meta);
+      if (nuxtApp.isHydrating && initialLayout && !isReadonly(to.meta.layout)) {
+        to.meta.layout = initialLayout;
+      }
+      nuxtApp._processingMiddleware = true;
+      if (import.meta.client || !nuxtApp.ssrContext?.islandContext) {
+        const middlewareEntries = /* @__PURE__ */ new Set([...globalMiddleware, ...nuxtApp._middleware.global]);
+        for (const component of to.matched) {
+          const componentMiddleware = component.meta.middleware;
+          if (!componentMiddleware) {
+            continue;
+          }
+          for (const entry of toArray(componentMiddleware)) {
+            middlewareEntries.add(entry);
+          }
+        }
+        if (isAppManifestEnabled) {
+          const routeRules = await nuxtApp.runWithContext(() => getRouteRules({ path: to.path }));
+          if (routeRules.appMiddleware) {
+            for (const key in routeRules.appMiddleware) {
+              if (routeRules.appMiddleware[key]) {
+                middlewareEntries.add(key);
+              } else {
+                middlewareEntries.delete(key);
+              }
+            }
+          }
+        }
+        for (const entry of middlewareEntries) {
+          const middleware = typeof entry === "string" ? nuxtApp._middleware.named[entry] || await namedMiddleware[entry]?.().then((r) => r.default || r) : entry;
+          if (!middleware) {
+            if (import.meta.dev) {
+              throw new Error(`Unknown route middleware: '${entry}'. Valid middleware: ${Object.keys(namedMiddleware).map((mw) => `'${mw}'`).join(", ")}.`);
+            }
+            throw new Error(`Unknown route middleware: '${entry}'.`);
+          }
+          try {
+            if (import.meta.dev) {
+              nuxtApp._processingMiddleware = middleware._path || (typeof entry === "string" ? entry : true);
+            }
+            const result = await nuxtApp.runWithContext(() => middleware(to, from));
+            if (import.meta.server || !nuxtApp.payload.serverRendered && nuxtApp.isHydrating) {
+              if (result === false || result instanceof Error) {
+                const error2 = result || createError({
+                  statusCode: 404,
+                  statusMessage: `Page Not Found: ${initialURL}`
+                });
+                await nuxtApp.runWithContext(() => showError(error2));
+                return false;
+              }
+            }
+            if (result === true) {
+              continue;
+            }
+            if (result === false) {
+              return result;
+            }
+            if (result) {
+              if (isNuxtError(result) && result.fatal) {
+                await nuxtApp.runWithContext(() => showError(result));
+              }
+              return result;
+            }
+          } catch (err) {
+            const error2 = createError(err);
+            if (error2.fatal) {
+              await nuxtApp.runWithContext(() => showError(error2));
+            }
+            return error2;
+          }
+        }
+      }
+    });
+    router.onError(async () => {
+      delete nuxtApp._processingMiddleware;
+      await nuxtApp.callHook("page:loading:end");
+    });
+    router.afterEach((to) => {
+      if (to.matched.length === 0) {
+        return nuxtApp.runWithContext(() => showError(createError({
+          statusCode: 404,
+          fatal: false,
+          statusMessage: `Page not found: ${to.fullPath}`,
+          data: {
+            path: to.fullPath
+          }
+        })));
+      }
+    });
+    nuxtApp.hooks.hookOnce("app:created", async () => {
+      try {
+        if ("name" in resolvedInitialRoute) {
+          resolvedInitialRoute.name = void 0;
+        }
+        await router.replace({
+          ...resolvedInitialRoute,
+          force: true
+        });
+        router.options.scrollBehavior = routerOptions.scrollBehavior;
+      } catch (error2) {
+        await nuxtApp.runWithContext(() => showError(error2));
+      }
+    });
+    return { provide: { router } };
+  }
+});
+export default plugin;

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

@@ -0,0 +1,3 @@
+import type { RouterConfig } from 'nuxt/schema';
+declare const _default: RouterConfig;
+export default _default;

package/dist/pages/runtime/router.options.js

@@ -0,0 +1,60 @@
+import { START_LOCATION } from "vue-router";
+import { useNuxtApp } from "#app/nuxt";
+import { isChangingPage } from "#app/components/utils";
+import { useRouter } from "#app/composables/router";
+export default {
+  scrollBehavior(to, from, savedPosition) {
+    const nuxtApp = useNuxtApp();
+    const hashScrollBehaviour = useRouter().options?.scrollBehaviorType ?? "auto";
+    if (to.path.replace(/\/$/, "") === from.path.replace(/\/$/, "")) {
+      if (from.hash && !to.hash) {
+        return { left: 0, top: 0 };
+      }
+      if (to.hash) {
+        return { el: to.hash, top: _getHashElementScrollMarginTop(to.hash), behavior: hashScrollBehaviour };
+      }
+      return false;
+    }
+    const routeAllowsScrollToTop = typeof to.meta.scrollToTop === "function" ? to.meta.scrollToTop(to, from) : to.meta.scrollToTop;
+    if (routeAllowsScrollToTop === false) {
+      return false;
+    }
+    const hookToWait = nuxtApp._runningTransition ? "page:transition:finish" : "page:loading:end";
+    return new Promise((resolve) => {
+      if (from === START_LOCATION) {
+        resolve(_calculatePosition(to, from, savedPosition, hashScrollBehaviour));
+        return;
+      }
+      nuxtApp.hooks.hookOnce(hookToWait, () => {
+        requestAnimationFrame(() => resolve(_calculatePosition(to, from, savedPosition, hashScrollBehaviour)));
+      });
+    });
+  }
+};
+function _getHashElementScrollMarginTop(selector) {
+  try {
+    const elem = document.querySelector(selector);
+    if (elem) {
+      return (Number.parseFloat(getComputedStyle(elem).scrollMarginTop) || 0) + (Number.parseFloat(getComputedStyle(document.documentElement).scrollPaddingTop) || 0);
+    }
+  } catch {
+  }
+  return 0;
+}
+function _calculatePosition(to, from, savedPosition, defaultHashScrollBehaviour) {
+  if (savedPosition) {
+    return savedPosition;
+  }
+  const isPageNavigation = isChangingPage(to, from);
+  if (to.hash) {
+    return {
+      el: to.hash,
+      top: _getHashElementScrollMarginTop(to.hash),
+      behavior: isPageNavigation ? defaultHashScrollBehaviour : "instant"
+    };
+  }
+  return {
+    left: 0,
+    top: 0
+  };
+}

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

@@ -0,0 +1,11 @@
+import type { RouteLocationNormalizedLoaded, RouterView } from 'vue-router';
+type InstanceOf<T> = T extends new (...args: any[]) => infer R ? R : never;
+type RouterViewSlot = Exclude<InstanceOf<typeof RouterView>['$slots']['default'], undefined>;
+export type RouterViewSlotProps = Parameters<RouterViewSlot>[0];
+export declare const generateRouteKey: (routeProps: RouterViewSlotProps, override?: string | ((route: RouteLocationNormalizedLoaded) => string)) => string | false | undefined;
+export declare const wrapInKeepAlive: (props: any, children: any) => {
+    default: () => any;
+};
+/** @since 3.9.0 */
+export declare function toArray<T>(value: T | T[]): T[];
+export {};

package/dist/pages/runtime/utils.js

@@ -0,0 +1,18 @@
+import { KeepAlive, h } from "vue";
+const ROUTE_KEY_PARENTHESES_RE = /(:\w+)\([^)]+\)/g;
+const ROUTE_KEY_SYMBOLS_RE = /(:\w+)[?+*]/g;
+const ROUTE_KEY_NORMAL_RE = /:\w+/g;
+const interpolatePath = (route, match) => {
+  return match.path.replace(ROUTE_KEY_PARENTHESES_RE, "$1").replace(ROUTE_KEY_SYMBOLS_RE, "$1").replace(ROUTE_KEY_NORMAL_RE, (r) => route.params[r.slice(1)]?.toString() || "");
+};
+export const generateRouteKey = (routeProps, override) => {
+  const matchedRoute = routeProps.route.matched.find((m) => m.components?.default === routeProps.Component.type);
+  const source = override ?? matchedRoute?.meta.key ?? (matchedRoute && interpolatePath(routeProps.route, matchedRoute));
+  return typeof source === "function" ? source(routeProps.route) : source;
+};
+export const wrapInKeepAlive = (props, children) => {
+  return { default: () => import.meta.client && props ? h(KeepAlive, props === true ? {} : props, children) : children };
+};
+export function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}

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

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

package/dist/pages/runtime/validate.js

@@ -0,0 +1,23 @@
+import { createError } from "#app/composables/error";
+import { defineNuxtRouteMiddleware } from "#app/composables/router";
+export default defineNuxtRouteMiddleware(async (to, from) => {
+  if (!to.meta?.validate) {
+    return;
+  }
+  const result = await Promise.resolve(to.meta.validate(to));
+  if (result === true) {
+    return;
+  }
+  const error = createError({
+    fatal: import.meta.client,
+    statusCode: result && result.statusCode || 404,
+    statusMessage: result && result.statusMessage || `Page Not Found: ${to.fullPath}`,
+    data: {
+      path: to.fullPath
+    }
+  });
+  if (typeof window !== "undefined") {
+    window.history.pushState({}, "", from.fullPath);
+  }
+  return error;
+});

package/kit.d.ts

@@ -0,0 +1 @@
+export * from '@nuxt/kit'

package/kit.js

@@ -0,0 +1 @@
+export * from '@nuxt/kit'

package/package.json

@@ -0,0 +1,156 @@
+{
+  "name": "@depup/nuxt",
+  "version": "4.2.2-depup.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nuxt/nuxt.git",
+    "directory": "packages/nuxt"
+  },
+  "homepage": "https://nuxt.com",
+  "description": "Nuxt is a free and open-source framework with an intuitive and extendable way to create type-safe, performant and production-grade full-stack web applications and websites with Vue.js.",
+  "license": "MIT",
+  "type": "module",
+  "types": "./types.d.ts",
+  "bin": {
+    "nuxi": "bin/nuxt.mjs",
+    "nuxt": "bin/nuxt.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./types.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./config": {
+      "types": "./config.d.ts",
+      "import": "./config.js",
+      "require": "./config.cjs"
+    },
+    "./schema": {
+      "types": "./schema.d.ts",
+      "import": "./schema.js"
+    },
+    "./kit": {
+      "types": "./kit.d.ts",
+      "import": "./kit.js"
+    },
+    "./app": {
+      "types": "./dist/app/index.d.ts",
+      "import": "./dist/app/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "imports": {
+    "#app": {
+      "types": "./dist/app/index.d.ts",
+      "import": "./dist/app/index.js"
+    },
+    "#app/nuxt": {
+      "types": "./dist/app/nuxt.d.ts",
+      "import": "./dist/app/nuxt.js"
+    },
+    "#unhead/composables": {
+      "types": "./dist/head/runtime/composables.d.ts",
+      "import": "./dist/head/runtime/composables.js"
+    }
+  },
+  "files": [
+    "app.d.ts",
+    "bin",
+    "types.d.ts",
+    "types.d.mts",
+    "dist",
+    "config.*",
+    "kit.*",
+    "schema.*"
+  ],
+  "dependencies": {
+    "@dxup/nuxt": "^0.3.2",
+    "@nuxt/cli": "^3.32.0",
+    "@nuxt/devtools": "^3.1.1",
+    "@nuxt/telemetry": "^2.6.6",
+    "@unhead/vue": "^2.1.2",
+    "@vue/shared": "^3.5.26",
+    "c12": "^3.3.3",
+    "chokidar": "^5.0.0",
+    "compatx": "^0.2.0",
+    "consola": "^3.4.2",
+    "cookie-es": "^2.0.0",
+    "defu": "^6.1.4",
+    "destr": "^2.0.5",
+    "devalue": "^5.6.1",
+    "errx": "^0.1.0",
+    "escape-string-regexp": "^5.0.0",
+    "exsolve": "^1.0.8",
+    "h3": "^2.0.1-rc.7",
+    "hookable": "^6.0.1",
+    "ignore": "^7.0.5",
+    "impound": "^1.0.0",
+    "jiti": "^2.6.1",
+    "klona": "^2.0.6",
+    "knitwork": "^1.3.0",
+    "magic-string": "^0.30.21",
+    "mlly": "^1.8.0",
+    "nanotar": "^0.2.0",
+    "nypm": "^0.6.2",
+    "ofetch": "^1.5.1",
+    "ohash": "^2.0.11",
+    "on-change": "^6.0.1",
+    "oxc-minify": "^0.108.0",
+    "oxc-parser": "^0.108.0",
+    "oxc-transform": "^0.108.0",
+    "oxc-walker": "^0.6.0",
+    "pathe": "^2.0.3",
+    "perfect-debounce": "^2.0.0",
+    "pkg-types": "^2.3.0",
+    "radix3": "^1.1.2",
+    "scule": "^1.3.0",
+    "semver": "^7.7.3",
+    "std-env": "^3.10.0",
+    "tinyglobby": "^0.2.15",
+    "ufo": "^1.6.2",
+    "ultrahtml": "^1.6.0",
+    "uncrypto": "^0.1.3",
+    "unctx": "^2.5.0",
+    "unimport": "^5.6.0",
+    "unplugin": "^2.3.11",
+    "unplugin-vue-router": "^0.19.2",
+    "untyped": "^2.0.0",
+    "vue": "^3.5.26",
+    "vue-router": "^4.6.4",
+    "@nuxt/kit": "4.2.2",
+    "@nuxt/nitro-server": "4.2.2",
+    "@nuxt/schema": "4.2.2",
+    "@nuxt/vite-builder": "4.2.2"
+  },
+  "devDependencies": {
+    "@nuxt/scripts": "^0.13.2",
+    "@parcel/watcher": "^2.5.4",
+    "@types/estree": "1.0.8",
+    "@vitejs/plugin-vue": "^6.0.3",
+    "@vitejs/plugin-vue-jsx": "^5.1.3",
+    "@vue/compiler-sfc": "^3.5.26",
+    "unbuild": "3.6.1",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.17",
+    "vue-bundle-renderer": "2.2.0",
+    "vue-sfc-transformer": "0.1.17"
+  },
+  "peerDependencies": {
+    "@parcel/watcher": "^2.1.0",
+    "@types/node": ">=18.12.0"
+  },
+  "peerDependenciesMeta": {
+    "@parcel/watcher": {
+      "optional": true
+    },
+    "@types/node": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "scripts": {
+    "test:attw": "attw --pack"
+  }
+}

package/schema.d.ts

@@ -0,0 +1 @@
+export * from '@nuxt/schema'

package/schema.js

@@ -0,0 +1 @@
+export * from '@nuxt/schema'

package/types.d.mts

@@ -0,0 +1,14 @@
+import type { SchemaDefinition } from 'nuxt/schema'
+import type { DefineNuxtConfig } from 'nuxt/config'
+
+export * from './dist/index.js'
+
+declare global {
+  const defineNuxtConfig: DefineNuxtConfig
+  const defineNuxtSchema: (schema: SchemaDefinition) => SchemaDefinition
+
+  interface ImportMeta {
+    url: string
+    readonly env: ImportMetaEnv
+  }
+}

package/types.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaDefinition } from 'nuxt/schema'
+import type { DefineNuxtConfig } from 'nuxt/config'
+
+export * from './dist/index'
+
+declare global {
+  const defineNuxtConfig: DefineNuxtConfig
+  const defineNuxtSchema: (schema: SchemaDefinition) => SchemaDefinition
+
+  interface ImportMeta {
+    url: string
+    readonly env: ImportMetaEnv
+  }
+}