@qzsy/vinext 0.1.7

package/dist/shims/app-router-scroll.js

@@ -0,0 +1,141 @@
+"use client";
+import { decodeHashFragment } from "./hash-scroll.js";
+import { consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent, markAppRouterScrollIntentHeadHoisted } from "./app-router-scroll-state.js";
+import * as React$1 from "react";
+import { jsx } from "react/jsx-runtime";
+import * as ReactDOM from "react-dom";
+//#region src/shims/app-router-scroll.tsx
+const AppRouterScrollCommitContext = React$1.createContext(null);
+const reactDomInternalsKey = "__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE";
+const rectProperties = [
+	"bottom",
+	"height",
+	"left",
+	"right",
+	"top",
+	"width",
+	"x",
+	"y"
+];
+function readFindDOMNode() {
+	const internals = Reflect.get(ReactDOM, reactDomInternalsKey);
+	if (typeof internals !== "object" || internals === null) return null;
+	const findDOMNode = Reflect.get(internals, "findDOMNode");
+	return typeof findDOMNode === "function" ? findDOMNode : null;
+}
+function findDOMNode(instance) {
+	if (typeof window === "undefined") return null;
+	const findDOMNodeImpl = readFindDOMNode();
+	if (!findDOMNodeImpl) return null;
+	const node = findDOMNodeImpl(instance);
+	return node instanceof Element || node instanceof Text ? node : null;
+}
+function shouldSkipElement(element) {
+	const position = getComputedStyle(element).position;
+	if (position === "fixed" || position === "sticky") return true;
+	const rect = element.getBoundingClientRect();
+	return rectProperties.every((property) => rect[property] === 0);
+}
+function topOfElementInViewport(element, viewportHeight) {
+	const rects = element.getClientRects();
+	if (rects.length === 0) return false;
+	let elementTop = Number.POSITIVE_INFINITY;
+	for (const rect of rects) if (rect.top < elementTop) elementTop = rect.top;
+	return elementTop >= 0 && elementTop <= viewportHeight;
+}
+function getHashFragmentDomNode(hash) {
+	const fragment = decodeHashFragment(hash.startsWith("#") ? hash.slice(1) : hash);
+	if (fragment === "top") return document.body;
+	return document.getElementById(fragment) ?? document.getElementsByName(fragment)[0] ?? null;
+}
+function isInDocumentHead(node) {
+	const head = node.ownerDocument?.head;
+	return head != null && head.contains(node);
+}
+function findNextScrollTarget(node) {
+	if (!(node instanceof Element)) return null;
+	if (isInDocumentHead(node)) return null;
+	let target = node;
+	while (!(target instanceof HTMLElement) || shouldSkipElement(target)) {
+		if (target.nextElementSibling === null) return null;
+		target = target.nextElementSibling;
+	}
+	return {
+		kind: "element",
+		element: target
+	};
+}
+function scrollToElement(target, hash) {
+	if (hash !== null) {
+		target.scrollIntoView({ behavior: "auto" });
+		return;
+	}
+	const htmlElement = document.documentElement;
+	const viewportHeight = htmlElement.clientHeight;
+	if (topOfElementInViewport(target, viewportHeight)) return;
+	htmlElement.scrollTop = 0;
+	if (!topOfElementInViewport(target, viewportHeight)) target.scrollIntoView({
+		behavior: "auto",
+		block: "start",
+		inline: "nearest"
+	});
+}
+var AppRouterScrollTargetInner = class extends React$1.Component {
+	scheduledCommitId = null;
+	schedulePotentialScroll = () => {
+		const commitId = this.props.commitId;
+		this.scheduledCommitId = commitId;
+		queueMicrotask(() => {
+			if (this.scheduledCommitId !== commitId) return;
+			this.handlePotentialScroll();
+		});
+	};
+	handlePotentialScroll = () => {
+		const intent = getPendingAppRouterScrollIntent();
+		if (intent === null) return;
+		if (this.props.commitId === null || intent.commitId !== this.props.commitId) return;
+		let node;
+		if (intent.hash !== null) node = getHashFragmentDomNode(intent.hash);
+		else node = null;
+		if (node === null) {
+			node = findDOMNode(this);
+			if (node !== null && isInDocumentHead(node)) {
+				markAppRouterScrollIntentHeadHoisted(intent, this.props.commitId);
+				return;
+			}
+		}
+		const next = findNextScrollTarget(node);
+		if (next === null) return;
+		const target = next.element;
+		const consumed = consumeAppRouterScrollIntent(intent, this.props.commitId);
+		if (consumed === null) return;
+		scrollToElement(target, consumed.hash);
+		target.focus();
+	};
+	componentDidMount() {
+		this.schedulePotentialScroll();
+	}
+	componentDidUpdate() {
+		this.schedulePotentialScroll();
+	}
+	componentWillUnmount() {
+		this.scheduledCommitId = null;
+	}
+	render() {
+		return this.props.children;
+	}
+};
+function AppRouterScrollCommitProvider({ children, commitId }) {
+	return /* @__PURE__ */ jsx(AppRouterScrollCommitContext.Provider, {
+		value: commitId,
+		children
+	});
+}
+function AppRouterScrollTarget({ children }) {
+	return /* @__PURE__ */ jsx(AppRouterScrollTargetInner, {
+		commitId: React$1.useContext(AppRouterScrollCommitContext),
+		children
+	});
+}
+//#endregion
+export { AppRouterScrollCommitProvider, AppRouterScrollTarget, AppRouterScrollTargetInner };

package/dist/shims/app.d.ts

@@ -0,0 +1,42 @@
+import React, { ComponentType } from "react";
+
+//#region src/shims/app.d.ts
+type AppProps<P = any> = {
+  Component: ComponentType<P> & {
+    getInitialProps?: (ctx: any) => any;
+  };
+  pageProps: P;
+  router?: any;
+  __N_SSG?: boolean;
+  __N_SSP?: boolean;
+};
+/**
+ * The context passed to `App.getInitialProps`. Mirrors Next.js's
+ * `AppContextType` from `packages/next/src/shared/lib/utils.ts`.
+ */
+type AppContext = {
+  Component: ComponentType<any> & {
+    getInitialProps?: (ctx: any) => any;
+  };
+  AppTree: ComponentType<any>;
+  ctx: any;
+  router: any;
+};
+/**
+ * The initial props shape returned by `App.getInitialProps`. Mirrors
+ * Next.js's `AppInitialProps` from `packages/next/src/shared/lib/utils.ts`.
+ */
+type AppInitialProps<PageProps = any> = {
+  pageProps: PageProps;
+};
+declare function appGetInitialProps({
+  Component,
+  ctx
+}: AppContext): Promise<AppInitialProps>;
+declare class App<P = any, CP = any, S = any> extends React.Component<P & AppProps<CP>, S> {
+  static origGetInitialProps: typeof appGetInitialProps;
+  static getInitialProps: typeof appGetInitialProps;
+  render(): React.ReactNode;
+}
+//#endregion
+export { AppContext, AppInitialProps, AppProps, App as default };

package/dist/shims/app.js

@@ -0,0 +1,48 @@
+import React from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/shims/app.tsx
+/**
+* next/app shim
+*
+* Provides the AppProps type and a runtime default `App` class component
+* for Pages Router fixtures that follow the canonical `_app.js` pattern:
+*
+*   import App from "next/app";
+*   export default class MyApp extends App { ... }
+*
+* or call `App.getInitialProps(appContext)` from a custom getInitialProps.
+*
+* Ported from Next.js:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/pages/_app.tsx
+*
+* Behavioural parity notes:
+* - `App.getInitialProps(appContext)` returns `{ pageProps }`, where
+*   `pageProps` comes from the wrapped page's own `getInitialProps` (if
+*   any). This matches Next.js's behaviour via `loadGetInitialProps`.
+* - `render()` returns `<Component {...pageProps} />` — the default
+*   behaviour Next.js documents for the built-in App.
+* - `origGetInitialProps` is preserved alongside `getInitialProps` for
+*   userland code that introspects the original implementation.
+*
+* Type signatures mirror Next.js's intentionally permissive `<P = any>`
+* generics so that userland subclasses like `class MyApp extends App`
+* type-check without forcing the caller to supply generic parameters.
+*/
+async function appGetInitialProps({ Component, ctx }) {
+	let pageProps = {};
+	if (typeof Component.getInitialProps === "function") {
+		pageProps = await Component.getInitialProps(ctx);
+		if (pageProps == null) pageProps = {};
+	}
+	return { pageProps };
+}
+var App = class extends React.Component {
+	static origGetInitialProps = appGetInitialProps;
+	static getInitialProps = appGetInitialProps;
+	render() {
+		const { Component, pageProps } = this.props;
+		return /* @__PURE__ */ jsx(Component, { ...pageProps });
+	}
+};
+//#endregion
+export { App as default };

package/dist/shims/before-interactive-context.d.ts

@@ -0,0 +1,40 @@
+import React from "react";
+
+//#region src/shims/before-interactive-context.d.ts
+/**
+ * A `<Script strategy="beforeInteractive">` captured during SSR.
+ *
+ * The Script shim hands these records to the SSR pipeline through
+ * `BeforeInteractiveContext` instead of rendering the `<script>` tag inline.
+ * The pipeline then emits the captured tag immediately after `<head>` opens,
+ * so the script runs before any React-hoisted stylesheets or modulepreload
+ * links. Matches the standard no-flash dark-mode pattern.
+ *
+ * Both inline (`children`/`dangerouslySetInnerHTML`) and external (`src`)
+ * beforeInteractive scripts flow through here, mirroring Next.js which registers
+ * inline and src beforeInteractive scripts equally in the App Router runtime
+ * (`(self.__next_s=...).push(...)`). An entry has `src` set for external
+ * scripts and `innerHTML` set for inline scripts (never both).
+ */
+type BeforeInteractiveInlineScript = {
+  /** Optional id attribute. */id?: string; /** External script URL. Set for src beforeInteractive scripts. */
+  src?: string;
+  /**
+   * Pre-escaped inline content (already passed through `escapeInlineContent`).
+   * Set for inline beforeInteractive scripts; omitted for src scripts.
+   */
+  innerHTML?: string; /** Nonce to emit on the `<script>` tag, when CSP is enabled. */
+  nonce?: string;
+  /**
+   * Additional HTML attributes to emit on the tag. Booleans render as the
+   * bare attribute name; strings render as `name="value"`. Reserved keys
+   * (id, nonce, src, children, dangerouslySetInnerHTML, strategy) are
+   * filtered out by the registrar.
+   */
+  attributes?: Record<string, string | boolean>;
+};
+type RegisterBeforeInteractiveInlineScript = (script: BeforeInteractiveInlineScript) => void;
+declare const BeforeInteractiveContext: React.Context<RegisterBeforeInteractiveInlineScript | null>;
+declare function useBeforeInteractiveRegister(): RegisterBeforeInteractiveInlineScript | null;
+//#endregion
+export { BeforeInteractiveContext, BeforeInteractiveInlineScript, RegisterBeforeInteractiveInlineScript, useBeforeInteractiveRegister };

package/dist/shims/before-interactive-context.js

@@ -0,0 +1,8 @@
+import React from "react";
+//#region src/shims/before-interactive-context.tsx
+const BeforeInteractiveContext = React.createContext(null);
+function useBeforeInteractiveRegister() {
+	return React.useContext(BeforeInteractiveContext);
+}
+//#endregion
+export { BeforeInteractiveContext, useBeforeInteractiveRegister };

package/dist/shims/cache-for-request.d.ts

@@ -0,0 +1,57 @@
+//#region src/shims/cache-for-request.d.ts
+/**
+ * Cache a factory function's result for the duration of a request.
+ *
+ * Returns a function that lazily invokes the factory on first call within
+ * a request, then returns the cached result for all subsequent calls in
+ * the same request. Each new request gets a fresh invocation.
+ *
+ * The factory function's identity (reference) is the cache key — no
+ * string keys, no collision risk between modules.
+ *
+ * Async factories are supported: the returned Promise is cached, so
+ * concurrent `await` calls within the same request share one invocation.
+ * If the Promise rejects, the cached entry is cleared so the next call
+ * can retry.
+ *
+ * Outside a request scope (tests, build-time), the factory runs every
+ * time with no caching — safe and predictable.
+ *
+ * @example
+ * ```ts
+ * import { cacheForRequest } from "vinext/cache";
+ *
+ * const getPrisma = cacheForRequest(() => {
+ *   const pool = new Pool({ connectionString: env.HYPERDRIVE.connectionString });
+ *   return new PrismaClient({ adapter: new PrismaPg(pool) });
+ * });
+ *
+ * // In a route handler or server component:
+ * const prisma = getPrisma(); // first call creates, subsequent calls reuse
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Async factory — Promise is cached, not re-invoked.
+ * // If it rejects, the cache is cleared for retry.
+ * const getDb = cacheForRequest(async () => {
+ *   const pool = new Pool({ connectionString });
+ *   await pool.connect();
+ *   return drizzle(pool);
+ * });
+ *
+ * const db = await getDb();
+ * ```
+ *
+ * @module
+ */
+/**
+ * Create a request-scoped cached version of a factory function.
+ *
+ * @param factory - Function that creates the value. Called once per request for sync
+ *   factories. Async factories that reject have their cache cleared, allowing retry.
+ * @returns A function with the same return type that caches the result per request.
+ */
+declare function cacheForRequest<T>(factory: () => T): () => T;
+//#endregion
+export { cacheForRequest };

package/dist/shims/cache-for-request.js

@@ -0,0 +1,72 @@
+import { getRequestContext, isInsideUnifiedScope } from "./unified-request-context.js";
+//#region src/shims/cache-for-request.ts
+/**
+* Cache a factory function's result for the duration of a request.
+*
+* Returns a function that lazily invokes the factory on first call within
+* a request, then returns the cached result for all subsequent calls in
+* the same request. Each new request gets a fresh invocation.
+*
+* The factory function's identity (reference) is the cache key — no
+* string keys, no collision risk between modules.
+*
+* Async factories are supported: the returned Promise is cached, so
+* concurrent `await` calls within the same request share one invocation.
+* If the Promise rejects, the cached entry is cleared so the next call
+* can retry.
+*
+* Outside a request scope (tests, build-time), the factory runs every
+* time with no caching — safe and predictable.
+*
+* @example
+* ```ts
+* import { cacheForRequest } from "vinext/cache";
+*
+* const getPrisma = cacheForRequest(() => {
+*   const pool = new Pool({ connectionString: env.HYPERDRIVE.connectionString });
+*   return new PrismaClient({ adapter: new PrismaPg(pool) });
+* });
+*
+* // In a route handler or server component:
+* const prisma = getPrisma(); // first call creates, subsequent calls reuse
+* ```
+*
+* @example
+* ```ts
+* // Async factory — Promise is cached, not re-invoked.
+* // If it rejects, the cache is cleared for retry.
+* const getDb = cacheForRequest(async () => {
+*   const pool = new Pool({ connectionString });
+*   await pool.connect();
+*   return drizzle(pool);
+* });
+*
+* const db = await getDb();
+* ```
+*
+* @module
+*/
+/**
+* Create a request-scoped cached version of a factory function.
+*
+* @param factory - Function that creates the value. Called once per request for sync
+*   factories. Async factories that reject have their cache cleared, allowing retry.
+* @returns A function with the same return type that caches the result per request.
+*/
+function cacheForRequest(factory) {
+	return () => {
+		if (!isInsideUnifiedScope()) return factory();
+		const cache = getRequestContext().requestCache;
+		if (cache.has(factory)) return cache.get(factory);
+		const value = factory();
+		if (value instanceof Promise) {
+			cache.set(factory, value);
+			value.catch(() => {
+				if (cache.get(factory) === value) cache.delete(factory);
+			});
+		} else cache.set(factory, value);
+		return value;
+	};
+}
+//#endregion
+export { cacheForRequest };

package/dist/shims/cache-handler.d.ts

@@ -0,0 +1,106 @@
+import { RenderObservation } from "../server/cache-proof.js";
+
+//#region src/shims/cache-handler.d.ts
+type CacheHandlerValue = {
+  lastModified: number;
+  age?: number;
+  cacheState?: string;
+  cacheControl?: CacheControlMetadata;
+  value: IncrementalCacheValue | null;
+};
+type CacheControlMetadata = {
+  revalidate: number;
+  expire?: number;
+};
+type IncrementalCacheValue = CachedFetchValue | CachedAppPageValue | CachedPagesValue | CachedRouteValue | CachedRedirectValue | CachedImageValue;
+type CachedFetchValue = {
+  kind: "FETCH";
+  data: {
+    headers: Record<string, string>;
+    body: string;
+    url: string;
+    status?: number;
+  };
+  tags?: string[];
+  revalidate: number | false;
+};
+type CachedAppPageValue = {
+  kind: "APP_PAGE";
+  html: string;
+  rscData: ArrayBuffer | undefined;
+  headers: Record<string, string | string[]> | undefined;
+  postponed: string | undefined;
+  renderObservation?: RenderObservation;
+  status: number | undefined;
+};
+type CachedPagesValue = {
+  kind: "PAGES";
+  html: string;
+  pageData: object;
+  generatedFromDataRequest?: boolean;
+  headers: Record<string, string | string[]> | undefined;
+  status: number | undefined;
+};
+type CachedRouteValue = {
+  kind: "APP_ROUTE";
+  body: ArrayBuffer;
+  status: number;
+  headers: Record<string, string | string[]>;
+};
+type CachedRedirectValue = {
+  kind: "REDIRECT";
+  props: object;
+};
+type CachedImageValue = {
+  kind: "IMAGE";
+  etag: string;
+  buffer: ArrayBuffer;
+  extension: string;
+  revalidate?: number;
+};
+type CacheHandlerContext = {
+  dev?: boolean;
+  maxMemoryCacheSize?: number;
+  revalidatedTags?: string[];
+  [key: string]: unknown;
+};
+type CacheHandler = {
+  get(key: string, ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
+  set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
+  revalidateTag(tags: string | string[], durations?: {
+    expire?: number;
+  }): Promise<void>;
+  resetRequestCache?(): void;
+};
+declare class NoOpCacheHandler implements CacheHandler {
+  get(_key: string, _ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
+  set(_key: string, _data: IncrementalCacheValue | null, _ctx?: Record<string, unknown>): Promise<void>;
+  revalidateTag(_tags: string | string[], _durations?: {
+    expire?: number;
+  }): Promise<void>;
+}
+type MemoryCacheHandlerOptions = Pick<CacheHandlerContext, "maxMemoryCacheSize"> & {
+  cacheMaxMemorySize?: number;
+};
+declare class MemoryCacheHandler implements CacheHandler {
+  private store;
+  private tagRevalidatedAt;
+  private readonly maxMemoryCacheSize;
+  private currentMemoryCacheSize;
+  constructor(options?: number | MemoryCacheHandlerOptions);
+  private estimateEntrySize;
+  private deleteEntry;
+  private touchEntry;
+  private evictLeastRecentlyUsed;
+  get(key: string, ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
+  set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
+  revalidateTag(tags: string | string[]): Promise<void>;
+  resetRequestCache(): void;
+}
+declare function configureMemoryCacheHandler(options?: MemoryCacheHandlerOptions): void;
+declare function setDataCacheHandler(handler: CacheHandler): void;
+declare function getDataCacheHandler(): CacheHandler;
+declare function setCacheHandler(handler: CacheHandler): void;
+declare function getCacheHandler(): CacheHandler;
+//#endregion
+export { CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, setCacheHandler, setDataCacheHandler };