vinext 0.1.7 → 0.2.0

package/dist/entries/app-rsc-manifest.js

@@ -74,6 +74,7 @@ function registerRouteModules(routes, imports) {
 			if (slot.pagePath) imports.getLazyLoaderVar(slot.pagePath);
 			if (slot.defaultPath) imports.getLazyLoaderVar(slot.defaultPath);
 			if (slot.layoutPath) imports.getLazyLoaderVar(slot.layoutPath);
+			for (const layoutPath of slot.configLayoutPaths ?? []) imports.getLazyLoaderVar(layoutPath);
 			if (slot.loadingPath) imports.getLazyLoaderVar(slot.loadingPath);
 			if (slot.errorPath) imports.getLazyLoaderVar(slot.errorPath);
 			for (const ir of slot.interceptingRoutes) {
@@ -112,6 +113,8 @@ function buildRouteEntries(routes, imports) {
       slotId: ${JSON.stringify(ir.slotId ?? null)},
       interceptLayouts: ${moduleArray(ir.layoutPaths.length)},
       __loadInterceptLayouts: ${lazyLoaderArray(ir.layoutPaths, imports)},
+      interceptLayoutSegments: ${JSON.stringify(ir.layoutSegments ?? [])},
+      interceptBranchSegments: ${JSON.stringify(ir.branchSegments ?? [])},
       page: null,
       __pageLoader: ${imports.getLazyLoaderVar(ir.pagePath)},
       params: ${JSON.stringify(ir.params)},
@@ -124,6 +127,8 @@ function buildRouteEntries(routes, imports) {
           sourcePageSegments: ${JSON.stringify(ir.sourcePageSegments)},
           interceptLayouts: ${moduleArray(ir.layoutPaths.length)},
           __loadInterceptLayouts: ${lazyLoaderArray(ir.layoutPaths, imports)},
+          interceptLayoutSegments: ${JSON.stringify(ir.layoutSegments ?? [])},
+          interceptBranchSegments: ${JSON.stringify(ir.branchSegments ?? [])},
           page: null,
           __pageLoader: ${imports.getLazyLoaderVar(ir.pagePath)},
           params: ${JSON.stringify(ir.params)},
@@ -137,6 +142,9 @@ function buildRouteEntries(routes, imports) {
         __loadDefault: ${slot.defaultPath ? imports.getLazyLoaderVar(slot.defaultPath) : "null"},
         layout: null,
         __loadLayout: ${slot.layoutPath ? imports.getLazyLoaderVar(slot.layoutPath) : "null"},
+        configLayouts: ${moduleArray(slot.configLayoutPaths?.length ?? 0)},
+        __loadConfigLayouts: ${lazyLoaderArray(slot.configLayoutPaths ?? [], imports)},
+        configLayoutTreePositions: ${JSON.stringify(slot.configLayoutTreePositions ?? [])},
         loading: null,
         __loadLoading: ${slot.loadingPath ? imports.getLazyLoaderVar(slot.loadingPath) : "null"},
         error: null,
@@ -173,6 +181,7 @@ ${interceptEntries.join(",\n")}
     layouts: ${moduleArray(route.layouts.length)},
     __loadLayouts: ${layoutLoaders},
     routeSegments: ${JSON.stringify(route.routeSegments)},
+    childrenRouteSegments: ${JSON.stringify(route.childrenRouteSegments ?? null)},
     templateTreePositions: ${JSON.stringify(route.templateTreePositions)},
     layoutTreePositions: ${JSON.stringify(route.layoutTreePositions)},
     templates: ${moduleArray(route.templates.length)},
@@ -185,6 +194,7 @@ ${interceptEntries.join(",\n")}
     slots: {
 ${slotEntries.join(",\n")}
     },
+    childrenSlot: ${JSON.stringify(route.childrenSlot ?? null)},
     siblingIntercepts: [
 ${siblingInterceptEntries.join(",\n")}
     ],

package/dist/entries/pages-client-entry.d.ts

@@ -1,11 +1,14 @@
 import { ResolvedNextConfig } from "../config/next-config.js";
 import { createValidFileMatcher } from "../routing/file-matcher.js";
+import { StaticMiddlewareMatcher } from "../build/report.js";
 import { VinextLinkPrefetchRoute } from "../client/vinext-next-data.js";
 
 //#region src/entries/pages-client-entry.d.ts
 declare function generateClientEntry(pagesDir: string, nextConfig: ResolvedNextConfig, fileMatcher: ReturnType<typeof createValidFileMatcher>, options?: {
   appPrefetchRoutes?: readonly VinextLinkPrefetchRoute[];
   instrumentationClientPath?: string | null;
+  middlewareMatcher?: StaticMiddlewareMatcher | undefined;
+  reactPreamble?: boolean;
 }): Promise<string>;
 //#endregion
 export { generateClientEntry };

package/dist/entries/pages-client-entry.js

@@ -2,6 +2,9 @@ import { normalizePathSeparators } from "../utils/path.js";
 import { findFileWithExts } from "../routing/file-matcher.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { apiRouter, pagesRouter } from "../routing/pages-router.js";
+import "./pages-entry-helpers.js";
+import { hasExportedName } from "../build/report.js";
+import { readFile } from "node:fs/promises";
 //#region src/entries/pages-client-entry.ts
 /**
 * Pages Router client hydration entry generator.
@@ -29,6 +32,12 @@ function toPagesLinkPrefetchRoute(route) {
 		patternParts: [...route.patternParts]
 	};
 }
+async function hasGetStaticPropsExport(filePath) {
+	return hasExportedName(await readFile(filePath, "utf8"), "getStaticProps");
+}
+async function hasGetServerSidePropsExport(filePath) {
+	return hasExportedName(await readFile(filePath, "utf8"), "getServerSideProps");
+}
 async function generateClientEntry(pagesDir, nextConfig, fileMatcher, options = {}) {
 	const pageRoutes = await pagesRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);
 	const apiRoutes = await apiRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);
@@ -39,6 +48,8 @@ async function generateClientEntry(pagesDir, nextConfig, fileMatcher, options =
 		...toPagesLinkPrefetchRoute(route),
 		documentOnly: true
 	}))];
+	const pagesSsgPatterns = (await Promise.all(pageRoutes.map(async (route) => await hasGetStaticPropsExport(route.filePath) ? patternToNextFormat(route.pattern) : null))).filter((pattern) => pattern !== null);
+	const pagesSspPatterns = (await Promise.all(pageRoutes.map(async (route) => await hasGetServerSidePropsExport(route.filePath) ? patternToNextFormat(route.pattern) : null))).filter((pattern) => pattern !== null);
 	const instrumentationClientPath = options.instrumentationClientPath ?? null;
 	const loaderEntries = pageRoutes.map((r) => {
 		const absPath = normalizePathSeparators(r.filePath);
@@ -46,7 +57,7 @@ async function generateClientEntry(pagesDir, nextConfig, fileMatcher, options =
 		return `  ${JSON.stringify(nextFormatPattern)}: () => import(${JSON.stringify(absPath)})`;
 	});
 	const appFileBase = appFilePath ? normalizePathSeparators(appFilePath) : void 0;
-	return `${instrumentationClientPath ? `import ${JSON.stringify(normalizePathSeparators(instrumentationClientPath))};\n` : ""}
+	return `${instrumentationClientPath ? `import ${JSON.stringify(normalizePathSeparators(instrumentationClientPath))};\n` : ""}${options.reactPreamble === false ? "" : "import \"@vitejs/plugin-react/preamble\";\n"}
 import "vinext/instrumentation-client";
 import React from "react";
 import { hydrateRoot } from "react-dom/client";
@@ -78,6 +89,9 @@ const appLoader = undefined;
 // can iterate in order and trust the first match.
 window.__VINEXT_PAGE_LOADERS__ = pageLoaders;
 window.__VINEXT_PAGE_PATTERNS__ = Object.keys(pageLoaders);
+window.__VINEXT_PAGES_SSG_PATTERNS__ = ${JSON.stringify(pagesSsgPatterns)};
+window.__VINEXT_PAGES_SSP_PATTERNS__ = ${JSON.stringify(pagesSspPatterns)};
+window.__VINEXT_MIDDLEWARE_MATCHER__ = ${JSON.stringify(options.middlewareMatcher)};
 window.__VINEXT_APP_LOADER__ = appLoader;
 // Expose the App Router prefetch manifest so Pages Router \`<Link>\`s and
 // \`Router.prefetch\` can detect when a prefetch target is actually an App
@@ -99,6 +113,7 @@ window.__VINEXT_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(appPrefetchRoutes)};
 // instead of issuing an RSC request). Set here AND in app-browser-entry.ts
 // so whichever entry runs first emits the Pages manifest.
 window.__VINEXT_PAGES_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(pagesPrefetchRoutes)};
+window.__VINEXT_CLIENT_REDIRECTS__ = ${JSON.stringify(nextConfig.redirects)};
 window.__VINEXT_CLIENT_REWRITES__ = ${JSON.stringify(nextConfig.rewrites)};
 
 const nextDataElement = document.getElementById("__NEXT_DATA__");

package/dist/entries/pages-server-entry.js

@@ -3,6 +3,7 @@ import { findFileWithExts } from "../routing/file-matcher.js";
 import { apiRouter, pagesRouter } from "../routing/pages-router.js";
 import { resolveEntryPath } from "./runtime-entry-module.js";
 import { isProxyFile } from "../server/middleware.js";
+import "./pages-entry-helpers.js";
 //#region src/entries/pages-server-entry.ts
 /**
 * Pages Router server entry generator.
@@ -127,6 +128,8 @@ import Router, { setSSRContext, wrapWithRouterContext, getPagesNavigationIsReady
 import { _runWithCacheState } from "vinext/shims/cache-request-state";
 import { configureMemoryCacheHandler as __configureMemoryCacheHandler } from "vinext/shims/cache-handler";
 import { registerConfiguredCacheAdapters as __registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
+import __pagesClientAssets from "virtual:vinext-pages-client-assets";
+import { setPagesClientAssets as __setPagesClientAssets } from "vinext/server/pages-client-assets";
 import { runWithPrivateCache } from "vinext/cache-runtime";
 import { ensureFetchPatch, runWithFetchCache } from "vinext/fetch-cache";
 import "vinext/router-state";
@@ -163,7 +166,7 @@ export const buildId = ${buildIdJson};
 export function normalizeDataRequest(request) {
   return __normalizePagesDataRequest(request, buildId);
 }
-const __hasMiddleware = ${JSON.stringify(Boolean(middlewarePath))};
+export const hasMiddleware = ${JSON.stringify(Boolean(middlewarePath))};
 
 // Full resolved config for production server (embedded at build time)
 export const vinextConfig = ${vinextConfigJson};
@@ -270,6 +273,7 @@ export function matchApiRoute(url, request) {
 // All next/*-derived values are passed as closures so the handler module
 // stays importable in test environments (the root vite.config.ts only
 // aliases vinext/shims/*, not next/*).
+__setPagesClientAssets(__pagesClientAssets);
 const _renderPage = __createPagesPageHandler({
   pageRoutes,
   errorPageRoute: _errorPageRoute,
@@ -285,7 +289,7 @@ const _renderPage = __createPagesPageHandler({
     disableOptimizedLoading: vinextConfig.disableOptimizedLoading,
   },
   buildId,
-  hasMiddleware: __hasMiddleware,
+  hasMiddleware,
   appAssetPath: _appAssetPath,
   hasRewrites:
     vinextConfig.rewrites.beforeFiles.length > 0 ||

package/dist/image/image-adapters-virtual.d.ts

@@ -0,0 +1,59 @@
+//#region src/image/image-adapters-virtual.d.ts
+/**
+ * Code generation for the `virtual:vinext-image-adapters` module, resolved by
+ * the vinext vite plugin from the user's `images` config ({@link VinextImageConfig}).
+ *
+ * The generated module exports `registerConfiguredImageOptimizer(env)`, which the
+ * server entries call on each request. It self-guards (the optimizer instantiates
+ * once per isolate) and is a no-op when nothing is configured. Registration is
+ * resilient: a factory that throws (e.g. a Cloudflare Images adapter on the
+ * Node.js server, where the `IMAGES` binding can't exist) is logged and skipped
+ * rather than failing every request, so the same config can be registered from
+ * every runtime/router entry. When no optimizer is registered, image requests
+ * fall back to serving the original asset unoptimized.
+ *
+ * Descriptor `options` are inlined into the generated module and forwarded to the
+ * factory at runtime, so a config-time builder like `imagesOptimizer({ binding })`
+ * never touches the Workers runtime — instantiation is deferred to the first
+ * request.
+ *
+ * This mirrors the cache-adapter pattern in `cache/cache-adapters-virtual.ts`.
+ */
+/**
+ * A serializable pointer to an image optimizer adapter module — the shape of the
+ * `images.optimizer` slot in the vinext() plugin config. Produced by an adapter
+ * builder (e.g. `imagesOptimizer(...)` from `@vinext/cloudflare/images/images-optimizer`)
+ * or written by hand. `options` must be JSON-serializable: it is inlined into the
+ * generated registration module and forwarded to the adapter factory at runtime.
+ */
+type ImageAdapterDescriptor<O extends Record<string, unknown> = Record<string, unknown>> = {
+  /**
+   * Module specifier (or absolute path, e.g. from `require.resolve(...)`) whose
+   * default export is an image optimizer factory.
+   */
+  adapter: string; /** JSON-serializable options forwarded to the factory at runtime. */
+  options?: O;
+};
+/**
+ * The `images` option of the vinext() plugin: declaratively register the
+ * server-side image optimizer (transform backend) instead of wiring `env.IMAGES`
+ * into a custom worker entry.
+ *
+ * This is complementary to the `images` field in `next.config.js`, which
+ * configures the standard Next.js image options (`remotePatterns`, `deviceSizes`,
+ * `dangerouslyAllowSVG`, etc.). Those continue to be read from next.config; this
+ * option only selects the runtime transform backend, which can't be expressed as
+ * serializable next.config data.
+ */
+type VinextImageConfig = {
+  /** Server-side image optimizer adapter (the `/_next/image` transform backend). */optimizer?: ImageAdapterDescriptor;
+};
+/** Public virtual module id imported by the server entries. */
+declare const VIRTUAL_IMAGE_ADAPTERS = "virtual:vinext-image-adapters";
+/**
+ * Generate the source of the `virtual:vinext-image-adapters` module for the
+ * given config. Always exports `registerConfiguredImageOptimizer(env)`.
+ */
+declare function generateImageAdaptersModule(images?: VinextImageConfig): string;
+//#endregion
+export { VIRTUAL_IMAGE_ADAPTERS, VinextImageConfig, generateImageAdaptersModule };

package/dist/image/image-adapters-virtual.js

@@ -0,0 +1,59 @@
+//#region src/image/image-adapters-virtual.ts
+/** Public virtual module id imported by the server entries. */
+const VIRTUAL_IMAGE_ADAPTERS = "virtual:vinext-image-adapters";
+/**
+* Serialize descriptor options into a JS expression for inlining. Plain JSON is
+* a valid JS literal; `undefined` when there are no options. Throws a clear
+* config-time error (not a runtime one) if options are not serializable.
+*/
+function inlineOptions(adapter, options) {
+	if (options === void 0) return "undefined";
+	try {
+		return JSON.stringify(options);
+	} catch (cause) {
+		throw new Error(`[vinext] image adapter "${adapter}" options must be JSON-serializable.`, { cause });
+	}
+}
+/**
+* Generate the source of the `virtual:vinext-image-adapters` module for the
+* given config. Always exports `registerConfiguredImageOptimizer(env)`.
+*/
+function generateImageAdaptersModule(images) {
+	const optimizer = images?.optimizer;
+	if (!optimizer?.adapter) return [
+		"// vinext: no images.optimizer adapter configured — registration is a no-op.",
+		"export function registerConfiguredImageOptimizer() {}",
+		""
+	].join("\n");
+	return [
+		"// vinext: generated from the `images` option in your vinext() plugin config.",
+		`import __vinextImageOptimizerFactory from ${JSON.stringify(optimizer.adapter)};`,
+		`import { setImageOptimizer } from "vinext/server/image-optimization";`,
+		"",
+		"// A factory that throws (e.g. a missing binding on an incompatible runtime)",
+		"// is logged and skipped so images fall back to unoptimized passthrough.",
+		"function __vinextFormatAdapterError(error) {",
+		"  if (error instanceof Error && error.message) return error.message;",
+		"  try {",
+		"    return String(error);",
+		"  } catch {",
+		"    return '<unknown error>';",
+		"  }",
+		"}",
+		"",
+		"let __vinextImageOptimizerRegistered = false;",
+		"",
+		"export function registerConfiguredImageOptimizer(env) {",
+		"  if (__vinextImageOptimizerRegistered) return;",
+		"  __vinextImageOptimizerRegistered = true;",
+		"  try {",
+		`    setImageOptimizer(__vinextImageOptimizerFactory({ env, options: ${inlineOptions(optimizer.adapter, optimizer.options)} }));`,
+		"  } catch (error) {",
+		"    console.warn(\"[vinext] failed to initialize the configured image optimizer; serving images unoptimized.\\n\" + __vinextFormatAdapterError(error));",
+		"  }",
+		"}",
+		""
+	].join("\n");
+}
+//#endregion
+export { VIRTUAL_IMAGE_ADAPTERS, generateImageAdaptersModule };

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { NextConfig, NextConfigInput } from "./config/next-config.js";
 import { AppStaticExportOptions, StaticExportOptions, StaticExportResult, staticExportApp, staticExportPages } from "./build/static-export.js";
 import { VinextCacheConfig } from "./cache/cache-adapters-virtual.js";
+import { VinextPrerenderConfig } from "./config/prerender.js";
+import { VinextImageConfig } from "./image/image-adapters-virtual.js";
 import { PluginOption } from "vite";
 import { Options } from "@vitejs/plugin-react";
 
@@ -79,6 +81,26 @@ type VinextOptions = {
    * @default false
    */
   precompress?: boolean;
+  /**
+   * Pre-render routes after `vinext build` without passing
+   * `--prerender-all`.
+   *
+   * Use `true` as shorthand for `{ routes: "*" }`. The object form is
+   * available so future releases can support narrower route selections, but
+   * currently only `"*"` is supported.
+   *
+   * The `vinext build --prerender-all` and `vinext deploy --prerender-all`
+   * flags still work and take priority when present.
+   *
+   * @example
+   * vinext({ prerender: true })
+   *
+   * @example
+   * vinext({ prerender: { routes: "*" } })
+   *
+   * @default undefined
+   */
+  prerender?: VinextPrerenderConfig;
   /**
    * Configure cache handlers declaratively, so you don't need a custom worker
    * entry that calls `setDataCacheHandler()` / `setCdnCacheAdapter()`. Each slot
@@ -97,6 +119,17 @@ type VinextOptions = {
    * })
    */
   cache?: VinextCacheConfig;
+  /**
+   * Configure the server-side image optimizer declaratively. The adapter factory
+   * receives the host `env`, allowing bindings such as Cloudflare Images to be
+   * used by both built-in and custom worker entrypoints that forward `env`.
+   *
+   * @example
+   * import { imagesOptimizer } from "@vinext/cloudflare/images/images-optimizer";
+   *
+   * vinext({ images: { optimizer: imagesOptimizer() } })
+   */
+  images?: VinextImageConfig;
   /**
    * Experimental vinext-only feature flags.
    */