@qzsy/vinext 0.1.7

package/dist/shims/internal/app-page-props-cache-key.js

@@ -0,0 +1,16 @@
+//#region src/shims/internal/app-page-props-cache-key.ts
+const APP_PAGE_PROPS_CACHE_KEY_MARKER = Symbol.for("vinext.appPagePropsCacheKeyMarker");
+function markAppPagePropsForUseCache(props) {
+	Object.defineProperty(props, APP_PAGE_PROPS_CACHE_KEY_MARKER, {
+		configurable: false,
+		enumerable: false,
+		value: true,
+		writable: false
+	});
+	return props;
+}
+function isMarkedAppPagePropsObject(value) {
+	return Reflect.get(value, APP_PAGE_PROPS_CACHE_KEY_MARKER) === true;
+}
+//#endregion
+export { isMarkedAppPagePropsObject, markAppPagePropsForUseCache };

package/dist/shims/internal/app-route-detection.d.ts

@@ -0,0 +1,39 @@
+import { VinextLinkPrefetchRoute } from "../../client/vinext-next-data.js";
+
+//#region src/shims/internal/app-route-detection.d.ts
+declare global {
+  interface Window {
+    __VINEXT_LINK_PREFETCH_ROUTES__?: VinextLinkPrefetchRoute[];
+  }
+}
+/**
+ * Pages Router `components` map shape. Next.js types this loosely (route
+ * pattern → `PrivateRouteInfo`), but for the App Router-detected case it
+ * stores `{ __appRouter: true }` as a marker (see Next.js source link above).
+ * Vinext only writes the marker variant; reads are by test code that checks
+ * for `__appRouter: true`.
+ */
+type PagesRouterComponentsMap = Record<string, {
+  __appRouter: true;
+} | Record<string, unknown>>;
+/**
+ * Get-or-create the Pages Router `components` map. Returns the same object
+ * on every call so `router.components` and `window.next.router.components`
+ * have referential identity.
+ */
+declare function getPagesRouterComponentsMap(): PagesRouterComponentsMap;
+/**
+ * Record `components[pathname] = { __appRouter: true }` on the shared
+ * Pages Router map when the href matches an App Router route. No-op when the
+ * manifest is absent, the URL is external, or no app route matches.
+ *
+ * `pathname` is the basePath-stripped, trailing-slash-stripped path —
+ * matching Next.js's `removeTrailingSlash(removeBasePath(pathname))` key used
+ * at read time (router.ts:1442). Stripping here ensures the write and read
+ * keys agree regardless of whether the caller normalised trailing slashes
+ * first (e.g. `link.tsx` normalises to match `trailingSlash` config before
+ * calling, while `router.prefetch()` passes the raw user-supplied URL).
+ */
+declare function markAppRouteDetectedOnPrefetch(href: string, basePath: string): void;
+//#endregion
+export { getPagesRouterComponentsMap, markAppRouteDetectedOnPrefetch };

package/dist/shims/internal/app-route-detection.js

@@ -0,0 +1,62 @@
+import { removeTrailingSlash, stripBasePath } from "../../utils/base-path.js";
+import { getLocalePathPrefix } from "../../utils/domain-locale.js";
+import { resolveHybridClientRouteOwner } from "./hybrid-client-route-owner.js";
+//#region src/shims/internal/app-route-detection.ts
+const _COMPONENTS_KEY = Symbol.for("vinext.pagesRouter.components");
+/**
+* Get-or-create the Pages Router `components` map. Returns the same object
+* on every call so `router.components` and `window.next.router.components`
+* have referential identity.
+*/
+function getPagesRouterComponentsMap() {
+	const globalState = globalThis;
+	let components = globalState[_COMPONENTS_KEY];
+	if (!components) {
+		components = {};
+		globalState[_COMPONENTS_KEY] = components;
+	}
+	return components;
+}
+/**
+* Resolve a prefetch href to a same-origin pathname (basePath-stripped),
+* suitable as the key used by Next.js for `router.components[urlPathname]`.
+*
+* Returns null for external URLs, malformed URLs, or non-browser contexts.
+*/
+function resolveSameOriginPathname(href, basePath) {
+	if (typeof window === "undefined") return null;
+	let url;
+	try {
+		url = new URL(href, window.location.href);
+	} catch {
+		return null;
+	}
+	if (url.origin !== window.location.origin) return null;
+	const pathname = stripBasePath(url.pathname, basePath);
+	const locale = getLocalePathPrefix(pathname, window.__VINEXT_LOCALES__);
+	if (!locale) return pathname;
+	const localePrefixLength = locale.length + 1;
+	return pathname.length === localePrefixLength ? "/" : pathname.slice(localePrefixLength);
+}
+/**
+* Record `components[pathname] = { __appRouter: true }` on the shared
+* Pages Router map when the href matches an App Router route. No-op when the
+* manifest is absent, the URL is external, or no app route matches.
+*
+* `pathname` is the basePath-stripped, trailing-slash-stripped path —
+* matching Next.js's `removeTrailingSlash(removeBasePath(pathname))` key used
+* at read time (router.ts:1442). Stripping here ensures the write and read
+* keys agree regardless of whether the caller normalised trailing slashes
+* first (e.g. `link.tsx` normalises to match `trailingSlash` config before
+* calling, while `router.prefetch()` passes the raw user-supplied URL).
+*/
+function markAppRouteDetectedOnPrefetch(href, basePath) {
+	if (typeof window === "undefined") return;
+	if (resolveHybridClientRouteOwner(href, basePath) !== "app") return;
+	const rawPathname = resolveSameOriginPathname(href, basePath);
+	if (rawPathname === null) return;
+	const pathname = removeTrailingSlash(rawPathname);
+	getPagesRouterComponentsMap()[pathname] = { __appRouter: true };
+}
+//#endregion
+export { getPagesRouterComponentsMap, markAppRouteDetectedOnPrefetch };

package/dist/shims/internal/app-router-context.d.ts

@@ -0,0 +1,31 @@
+import * as React$1 from "react";
+
+//#region src/shims/internal/app-router-context.d.ts
+type NavigateOptions = {
+  scroll?: boolean;
+};
+type PrefetchOptions = {
+  kind?: unknown;
+  onInvalidate?: () => void;
+};
+type AppRouterInstance = {
+  bfcacheId: string;
+  back(): void;
+  forward(): void;
+  refresh(): void;
+  push(href: string, options?: NavigateOptions): void;
+  replace(href: string, options?: NavigateOptions): void;
+  prefetch(href: string, options?: PrefetchOptions): void;
+  /**
+   * Perform an experimental gesture transition navigation.
+   * Only available when experimental.gestureTransition is enabled.
+   */
+  experimental_gesturePush?(href: string, options?: NavigateOptions): void;
+};
+declare const AppRouterContext: React$1.Context<AppRouterInstance | null> | null;
+declare const GlobalLayoutRouterContext: React$1.Context<unknown> | null;
+declare const LayoutRouterContext: React$1.Context<unknown> | null;
+declare const MissingSlotContext: React$1.Context<Set<string>> | null;
+declare const TemplateContext: React$1.Context<unknown> | null;
+//#endregion
+export { AppRouterContext, AppRouterInstance, GlobalLayoutRouterContext, LayoutRouterContext, MissingSlotContext, NavigateOptions, PrefetchOptions, TemplateContext };

package/dist/shims/internal/app-router-context.js

@@ -0,0 +1,28 @@
+import * as React$1 from "react";
+//#region src/shims/internal/app-router-context.ts
+/**
+* Shim for next/dist/shared/lib/app-router-context.shared-runtime
+*
+* Used by: @clerk/nextjs, next-intl, next-nprogress-bar, nextjs-toploader,
+* next-view-transitions. Mostly type-only imports in published .d.ts files.
+*
+* We export the types and minimal context objects so these libraries resolve.
+*/
+const APP_ROUTER_CONTEXT_KEY = Symbol.for("vinext.appRouterContext");
+const GLOBAL_LAYOUT_ROUTER_CONTEXT_KEY = Symbol.for("vinext.globalLayoutRouterContext");
+const LAYOUT_ROUTER_CONTEXT_KEY = Symbol.for("vinext.layoutRouterContext");
+const MISSING_SLOT_CONTEXT_KEY = Symbol.for("vinext.missingSlotContext");
+const TEMPLATE_CONTEXT_KEY = Symbol.for("vinext.templateContext");
+function getOrCreateContext(key, defaultValue) {
+	if (typeof React$1.createContext !== "function") return null;
+	const globalState = globalThis;
+	if (!globalState[key]) globalState[key] = React$1.createContext(defaultValue);
+	return globalState[key] ?? null;
+}
+const AppRouterContext = getOrCreateContext(APP_ROUTER_CONTEXT_KEY, null);
+const GlobalLayoutRouterContext = getOrCreateContext(GLOBAL_LAYOUT_ROUTER_CONTEXT_KEY, null);
+const LayoutRouterContext = getOrCreateContext(LAYOUT_ROUTER_CONTEXT_KEY, null);
+const MissingSlotContext = getOrCreateContext(MISSING_SLOT_CONTEXT_KEY, /* @__PURE__ */ new Set());
+const TemplateContext = getOrCreateContext(TEMPLATE_CONTEXT_KEY, null);
+//#endregion
+export { AppRouterContext, GlobalLayoutRouterContext, LayoutRouterContext, MissingSlotContext, TemplateContext };

package/dist/shims/internal/cookie-serialize.d.ts

@@ -0,0 +1,45 @@
+//#region src/shims/internal/cookie-serialize.d.ts
+/**
+ * Shared Set-Cookie serialization for the next/headers and next/server shims.
+ *
+ * Two call sites — `cookies().set()` in headers.ts and `ResponseCookies.set()`
+ * in server.ts — produce identical Set-Cookie header strings. Keep the
+ * encoding, attribute order, and validation in one place so subtle RFC 6265
+ * details (escaping, attribute ordering, etc.) cannot drift between them.
+ *
+ * Note: this is a value-encoding helper for response cookies only. The
+ * request `Cookie:` header serialization in `RequestCookies._serialize`
+ * (server.ts) intentionally lives separately — it builds a different format
+ * (no attributes, just `name=value; name=value`) and shouldn't share this
+ * code.
+ */
+type SerializeSetCookieOptions = {
+  path?: string;
+  domain?: string;
+  maxAge?: number;
+  expires?: Date;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: "Strict" | "Lax" | "None";
+};
+declare function validateCookieName(name: string): void;
+/**
+ * Validate cookie attribute values (path, domain) to prevent injection
+ * via semicolons, newlines, or other control characters.
+ */
+declare function validateCookieAttributeValue(value: string, attributeName: string): void;
+/**
+ * Build a Set-Cookie header string from a cookie name, value, and attributes.
+ *
+ * - Encodes the value with `encodeURIComponent`.
+ * - Defaults `Path` to `/` (matching @edge-runtime/cookies and Next.js).
+ * - Validates path/domain to reject control characters and semicolons.
+ * - Emits attributes in the order: Path, Domain, Max-Age, Expires, HttpOnly,
+ *   Secure, SameSite.
+ *
+ * The caller is responsible for validating the cookie name (typically before
+ * mutating any internal state) via `validateCookieName`.
+ */
+declare function serializeSetCookie(name: string, value: string, options?: SerializeSetCookieOptions): string;
+//#endregion
+export { serializeSetCookie, validateCookieAttributeValue, validateCookieName };

package/dist/shims/internal/cookie-serialize.js

@@ -0,0 +1,49 @@
+//#region src/shims/internal/cookie-serialize.ts
+/**
+* RFC 6265 §4.1.1: cookie-name is a token (RFC 2616 §2.2).
+* Allowed: any visible ASCII (0x21-0x7E) except separators: ()<>@,;:\"/[]?={}
+*/
+const VALID_COOKIE_NAME_RE = /^[\x21\x23-\x27\x2A\x2B\x2D\x2E\x30-\x39\x41-\x5A\x5E-\x7A\x7C\x7E]+$/;
+function validateCookieName(name) {
+	if (!name || !VALID_COOKIE_NAME_RE.test(name)) throw new Error(`Invalid cookie name: ${JSON.stringify(name)}`);
+}
+/**
+* Validate cookie attribute values (path, domain) to prevent injection
+* via semicolons, newlines, or other control characters.
+*/
+function validateCookieAttributeValue(value, attributeName) {
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code <= 31 || code === 127 || value[i] === ";") throw new Error(`Invalid cookie ${attributeName} value: ${JSON.stringify(value)}`);
+	}
+}
+/**
+* Build a Set-Cookie header string from a cookie name, value, and attributes.
+*
+* - Encodes the value with `encodeURIComponent`.
+* - Defaults `Path` to `/` (matching @edge-runtime/cookies and Next.js).
+* - Validates path/domain to reject control characters and semicolons.
+* - Emits attributes in the order: Path, Domain, Max-Age, Expires, HttpOnly,
+*   Secure, SameSite.
+*
+* The caller is responsible for validating the cookie name (typically before
+* mutating any internal state) via `validateCookieName`.
+*/
+function serializeSetCookie(name, value, options) {
+	const parts = [`${name}=${encodeURIComponent(value)}`];
+	const path = options?.path ?? "/";
+	validateCookieAttributeValue(path, "Path");
+	parts.push(`Path=${path}`);
+	if (options?.domain) {
+		validateCookieAttributeValue(options.domain, "Domain");
+		parts.push(`Domain=${options.domain}`);
+	}
+	if (options?.maxAge !== void 0) parts.push(`Max-Age=${options.maxAge}`);
+	if (options?.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
+	if (options?.httpOnly) parts.push("HttpOnly");
+	if (options?.secure) parts.push("Secure");
+	if (options?.sameSite) parts.push(`SameSite=${options.sameSite}`);
+	return parts.join("; ");
+}
+//#endregion
+export { serializeSetCookie, validateCookieAttributeValue, validateCookieName };

package/dist/shims/internal/cookies.d.ts

@@ -0,0 +1,2 @@
+import { RequestCookies, ResponseCookies } from "../server.js";
+export { RequestCookies, ResponseCookies };

package/dist/shims/internal/cookies.js

@@ -0,0 +1,2 @@
+import { RequestCookies, ResponseCookies } from "../server.js";
+export { RequestCookies, ResponseCookies };

package/dist/shims/internal/hybrid-client-route-owner.d.ts

@@ -0,0 +1,31 @@
+import { NextRewrite } from "../../config/next-config.js";
+import { VinextLinkPrefetchRoute, VinextPagesLinkPrefetchRoute } from "../../client/vinext-next-data.js";
+
+//#region src/shims/internal/hybrid-client-route-owner.d.ts
+type HybridClientOwner = "app" | "document" | "pages";
+declare global {
+  interface Window {
+    __VINEXT_LINK_PREFETCH_ROUTES__?: VinextLinkPrefetchRoute[];
+    __VINEXT_PAGES_LINK_PREFETCH_ROUTES__?: VinextPagesLinkPrefetchRoute[];
+    __VINEXT_CLIENT_REWRITES__?: {
+      afterFiles: NextRewrite[];
+      beforeFiles: NextRewrite[];
+      fallback: NextRewrite[];
+    };
+  }
+}
+/**
+ * Decide which router should own a soft-navigated URL. Returns:
+ *   - "app"    → the App Router runtime handles the navigation (RSC fetch).
+ *   - "pages"  → Pages owns the URL; the caller must hard-navigate instead.
+ *   - null     → no router matched (preserves the existing 404 path).
+ *
+ * `basePath` must match what the page uses (typically `process.env.__NEXT_ROUTER_BASEPATH`).
+ *
+ * The lookup uses the App and Pages manifests on `window` so the same
+ * matcher trie produces the same result the server will see when the
+ * request lands.
+ */
+declare function resolveHybridClientRouteOwner(href: string, basePath: string): HybridClientOwner | null;
+//#endregion
+export { HybridClientOwner, resolveHybridClientRouteOwner };

package/dist/shims/internal/hybrid-client-route-owner.js

@@ -0,0 +1,143 @@
+import { compareHybridRoutePatterns } from "../../routing/utils.js";
+import { stripBasePath } from "../../utils/base-path.js";
+import { createRouteTrieCache, matchRouteWithTrie } from "../../routing/route-matching.js";
+import { isExternalUrl, matchRewrite, parseCookies } from "../../config/config-matchers.js";
+import { getLocalePathPrefix } from "../../utils/domain-locale.js";
+import { mergeRewriteQuery } from "../../utils/query.js";
+//#region src/shims/internal/hybrid-client-route-owner.ts
+/**
+* Client-side resolver that decides whether a URL should be soft-navigated
+* (App Router / RSC) or hard-navigated (Pages Router / document). Delegates
+* the owner decision to `compareHybridRoutePatterns` in `routing/utils.ts`
+* so the server and the client reach the same answer for the same
+* (pages pattern, app pattern) pair.
+*
+* Lives in `shims/internal/` because both `link.tsx` and the App Router
+* browser entry import it without pulling in the server route graph.
+*
+* The App + Pages route manifests are emitted once per page load by the
+* Vite plugin onto the matching `__VINEXT_*_PREFETCH_ROUTES__` window
+* globals (see `entries/app-browser-entry.ts` and
+* `entries/pages-client-entry.ts`). Hybrid builds expose both globals; a
+* single-router build only sets its own.
+*/
+function resolveClientRewrite(href, basePath, rewrites, continueAfterMatch = false) {
+	const initialUrl = new URL(href, window.location.href);
+	const basePathState = {
+		basePath,
+		hadBasePath: basePath ? initialUrl.pathname === basePath || initialUrl.pathname.startsWith(`${basePath}/`) : true
+	};
+	let currentHref = href;
+	let matched = false;
+	for (const rewrite of rewrites) {
+		const pathname = resolveSameOriginPathname(currentHref, basePath);
+		if (pathname === null) return null;
+		const url = new URL(currentHref, window.location.href);
+		const headers = new Headers({ "user-agent": globalThis.navigator?.userAgent ?? "" });
+		const context = {
+			cookies: parseCookies(globalThis.document?.cookie ?? ""),
+			headers,
+			host: url.hostname,
+			query: url.searchParams
+		};
+		const rewritten = matchRewrite(pathname, [rewrite], context, basePathState);
+		if (rewritten === null) continue;
+		if (isExternalUrl(rewritten)) return { kind: "document" };
+		currentHref = mergeRewriteQuery(currentHref, rewritten);
+		matched = true;
+		if (!continueAfterMatch) break;
+	}
+	return matched ? {
+		href: currentHref,
+		kind: "rewrite"
+	} : null;
+}
+const appRouteTrieCache = createRouteTrieCache();
+const pagesRouteTrieCache = createRouteTrieCache();
+/**
+* Build a `/`-joined pattern from a manifest's `patternParts`. Mirrors the
+* server-side route-graph shape (`{ pattern: string }`) so the
+* `compareHybridRoutePatterns` segment-rank comparator can score both Pages
+* and App patterns. The
+* `patternParts` array never includes an empty string for the static `/`
+* route (the App catch-all handles the bare path), so the simple join is
+* safe for everything the route trie actually matches.
+*/
+function patternFromParts(parts) {
+	return "/" + parts.join("/");
+}
+function resolveSameOriginPathname(href, basePath) {
+	if (typeof window === "undefined") return null;
+	let url;
+	try {
+		url = new URL(href, window.location.href);
+	} catch {
+		return null;
+	}
+	if (url.origin !== window.location.origin) return null;
+	const pathname = stripBasePath(url.pathname, basePath);
+	const locale = getLocalePathPrefix(pathname, window.__VINEXT_LOCALES__);
+	if (!locale) return pathname;
+	const localePrefixLength = locale.length + 1;
+	return pathname.length === localePrefixLength ? "/" : pathname.slice(localePrefixLength);
+}
+function matchAppRoute(href, basePath, routes) {
+	const pathname = resolveSameOriginPathname(href, basePath);
+	if (pathname === null) return null;
+	return matchRouteWithTrie(pathname, routes, appRouteTrieCache)?.route ?? null;
+}
+function matchPagesRoute(href, basePath, routes) {
+	const pathname = resolveSameOriginPathname(href, basePath);
+	if (pathname === null) return null;
+	return matchRouteWithTrie(pathname, routes, pagesRouteTrieCache)?.route ?? null;
+}
+/**
+* Decide which router should own a soft-navigated URL. Returns:
+*   - "app"    → the App Router runtime handles the navigation (RSC fetch).
+*   - "pages"  → Pages owns the URL; the caller must hard-navigate instead.
+*   - null     → no router matched (preserves the existing 404 path).
+*
+* `basePath` must match what the page uses (typically `process.env.__NEXT_ROUTER_BASEPATH`).
+*
+* The lookup uses the App and Pages manifests on `window` so the same
+* matcher trie produces the same result the server will see when the
+* request lands.
+*/
+function resolveHybridClientRouteOwner(href, basePath) {
+	if (typeof window === "undefined") return null;
+	const appRoutes = window.__VINEXT_LINK_PREFETCH_ROUTES__;
+	const pagesRoutes = window.__VINEXT_PAGES_LINK_PREFETCH_ROUTES__;
+	const rewrites = window.__VINEXT_CLIENT_REWRITES__;
+	if (rewrites) {
+		const beforeFilesRewrite = resolveClientRewrite(href, basePath, rewrites.beforeFiles, true);
+		if (beforeFilesRewrite?.kind === "document") return "document";
+		if (beforeFilesRewrite?.kind === "rewrite") href = beforeFilesRewrite.href;
+	}
+	let appMatch = appRoutes ? matchAppRoute(href, basePath, appRoutes) : null;
+	let pagesMatch = pagesRoutes ? matchPagesRoute(href, basePath, pagesRoutes) : null;
+	if (rewrites && (appMatch === null || appMatch.isDynamic) && (pagesMatch === null || pagesMatch.isDynamic)) for (const rewrite of rewrites.afterFiles) {
+		const afterFilesRewrite = resolveClientRewrite(href, basePath, [rewrite]);
+		if (afterFilesRewrite?.kind === "document") return "document";
+		if (afterFilesRewrite?.kind !== "rewrite") continue;
+		href = afterFilesRewrite.href;
+		appMatch = appRoutes ? matchAppRoute(href, basePath, appRoutes) : null;
+		pagesMatch = pagesRoutes ? matchPagesRoute(href, basePath, pagesRoutes) : null;
+		if (appMatch || pagesMatch) break;
+	}
+	if (rewrites && appMatch === null && pagesMatch === null) for (const rewrite of rewrites.fallback) {
+		const fallbackRewrite = resolveClientRewrite(href, basePath, [rewrite]);
+		if (fallbackRewrite?.kind === "document") return "document";
+		if (fallbackRewrite?.kind !== "rewrite") continue;
+		href = fallbackRewrite.href;
+		appMatch = appRoutes ? matchAppRoute(href, basePath, appRoutes) : null;
+		pagesMatch = pagesRoutes ? matchPagesRoute(href, basePath, pagesRoutes) : null;
+		if (appMatch || pagesMatch) break;
+	}
+	if (appMatch === null && pagesMatch === null) return null;
+	if (pagesMatch === null) return appMatch.documentOnly ? "document" : "app";
+	if (appMatch === null) return pagesMatch.documentOnly ? "document" : "pages";
+	const owner = compareHybridRoutePatterns(patternFromParts(pagesMatch.patternParts), pagesMatch.isDynamic, patternFromParts(appMatch.patternParts), appMatch.isDynamic);
+	return (owner === "app" ? appMatch : pagesMatch).documentOnly ? "document" : owner;
+}
+//#endregion
+export { resolveHybridClientRouteOwner };

package/dist/shims/internal/interpolate-as.d.ts

@@ -0,0 +1,25 @@
+import { UrlQuery } from "../../utils/query.js";
+
+//#region src/shims/internal/interpolate-as.d.ts
+/**
+ * Wire-compatible alias for Node's `querystring.ParsedUrlQuery`. Inlined here
+ * so this module has no dependency on the `querystring` types package.
+ */
+type ParsedUrlQuery = {
+  [key: string]: string | string[] | undefined;
+};
+type DynamicRouteHrefProjection = {
+  href: string;
+  params: string[];
+  query: ParsedUrlQuery;
+  routePathname: string;
+};
+/**
+ * Resolve a bracket-pattern route href against its displayed href. Query
+ * values can be supplied directly (object-form hrefs) or parsed from the route
+ * href (string-form hrefs). A `?` after `#` is part of the fragment, not a
+ * query delimiter.
+ */
+declare function interpolateDynamicRouteHref(routeHref: string, asHref: string, queryInput?: UrlQuery): DynamicRouteHrefProjection | null;
+//#endregion
+export { DynamicRouteHrefProjection, interpolateDynamicRouteHref };