vinext 0.0.30 → 0.0.31

package/dist/build/static-export.js

@@ -1,551 +1,57 @@
-import { patternToNextFormat } from "../routing/pages-router.js";
-import { safeJsonStringify } from "../server/html.js";
-import { escapeAttr } from "../shims/head.js";
-import path from "node:path";
-import fs from "node:fs";
-import React from "react";
-import { renderToReadableStream } from "react-dom/server.edge";
-import { createValidFileMatcher } from "../routing/file-matcher.js";
-function findFileWithExtensions(basePath, matcher) {
-    return matcher.dottedExtensions.some((ext) => fs.existsSync(basePath + ext));
-}
-/**
- * Render a React element to string using renderToReadableStream (Suspense support).
- * Uses Web Streams API — works in Node.js 18+ and Cloudflare Workers.
- */
-async function renderToStringAsync(element) {
-    const stream = await renderToReadableStream(element);
-    await stream.allReady;
-    return new Response(stream).text();
-}
-/**
- * Run static export for Pages Router.
- *
- * Creates a directory of static HTML files by rendering each route at build time.
- */
-export async function staticExportPages(options) {
-    const { server, routes, apiRoutes, pagesDir, outDir, config } = options;
-    const fileMatcher = createValidFileMatcher(config.pageExtensions);
-    const result = {
-        pageCount: 0,
-        files: [],
-        warnings: [],
-        errors: [],
-    };
-    // Ensure output directory exists
-    fs.mkdirSync(outDir, { recursive: true });
-    // Warn about API routes
-    if (apiRoutes.length > 0) {
-        result.warnings.push(`${apiRoutes.length} API route(s) skipped — API routes are not supported with output: 'export'`);
-    }
-    // Gather all pages to render (expand dynamic routes via getStaticPaths)
-    const pagesToRender = [];
-    for (const route of routes) {
-        // Skip internal pages
-        const routeName = path.basename(route.filePath, path.extname(route.filePath));
-        if (routeName.startsWith("_"))
-            continue;
-        const pageModule = await server.ssrLoadModule(route.filePath);
-        // Validate: getServerSideProps is not allowed with static export
-        if (typeof pageModule.getServerSideProps === "function") {
-            result.errors.push({
-                route: route.pattern,
-                error: `Page uses getServerSideProps which is not supported with output: 'export'. Use getStaticProps instead.`,
-            });
-            continue;
-        }
-        if (route.isDynamic) {
-            // Dynamic route — must have getStaticPaths
-            if (typeof pageModule.getStaticPaths !== "function") {
-                result.errors.push({
-                    route: route.pattern,
-                    error: `Dynamic route requires getStaticPaths with output: 'export'`,
-                });
-                continue;
-            }
-            const pathsResult = await pageModule.getStaticPaths({
-                locales: [],
-                defaultLocale: "",
-            });
-            const fallback = pathsResult?.fallback ?? false;
-            if (fallback !== false) {
-                result.errors.push({
-                    route: route.pattern,
-                    error: `getStaticPaths must return fallback: false with output: 'export' (got: ${JSON.stringify(fallback)})`,
-                });
-                continue;
-            }
-            const paths = pathsResult?.paths ?? [];
-            for (const { params } of paths) {
-                // Build the URL path from the route pattern and params
-                const urlPath = buildUrlFromParams(route.pattern, params);
-                pagesToRender.push({ route, urlPath, params });
-            }
-        }
-        else {
-            // Static route — render directly
-            pagesToRender.push({ route, urlPath: route.pattern, params: {} });
-        }
-    }
-    // Load shared components (_app, _document, head shim, dynamic shim)
-    let AppComponent = null;
-    const appPath = path.join(pagesDir, "_app");
-    if (findFileWithExtensions(appPath, fileMatcher)) {
-        try {
-            const appModule = await server.ssrLoadModule(appPath);
-            AppComponent = appModule.default ?? null;
-        }
-        catch {
-            // _app exists but failed to load
-        }
-    }
-    let DocumentComponent = null;
-    const docPath = path.join(pagesDir, "_document");
-    if (findFileWithExtensions(docPath, fileMatcher)) {
-        try {
-            const docModule = await server.ssrLoadModule(docPath);
-            DocumentComponent = docModule.default ?? null;
-        }
-        catch {
-            // _document exists but failed to load
-        }
-    }
-    const headShim = await server.ssrLoadModule("next/head");
-    const dynamicShim = await server.ssrLoadModule("next/dynamic");
-    const routerShim = await server.ssrLoadModule("next/router");
-    // Render each page
-    for (const { route, urlPath, params } of pagesToRender) {
-        try {
-            const html = await renderStaticPage({
-                server,
-                route,
-                urlPath,
-                params,
-                pagesDir,
-                config,
-                AppComponent,
-                DocumentComponent,
-                headShim,
-                dynamicShim,
-                routerShim,
-            });
-            const outputPath = getOutputPath(urlPath, config.trailingSlash);
-            const fullPath = path.join(outDir, outputPath);
-            fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-            fs.writeFileSync(fullPath, html, "utf-8");
-            result.files.push(outputPath);
-            result.pageCount++;
-        }
-        catch (e) {
-            result.errors.push({
-                route: urlPath,
-                error: e.message,
-            });
-        }
-    }
-    // Render 404 page
-    try {
-        const html404 = await renderErrorPage({
-            server,
-            pagesDir,
-            statusCode: 404,
-            AppComponent,
-            DocumentComponent,
-            headShim,
-            fileMatcher,
-        });
-        if (html404) {
-            const fullPath = path.join(outDir, "404.html");
-            fs.writeFileSync(fullPath, html404, "utf-8");
-            result.files.push("404.html");
-            result.pageCount++;
-        }
-    }
-    catch {
-        // No custom 404, skip
-    }
-    return result;
-}
-async function renderStaticPage(options) {
-    const { server, route, urlPath, params, config: _config, AppComponent, DocumentComponent, headShim, dynamicShim, routerShim, } = options;
-    // Set SSR context for router shim
-    if (typeof routerShim.setSSRContext === "function") {
-        routerShim.setSSRContext({
-            pathname: patternToNextFormat(route.pattern),
-            query: params,
-            asPath: urlPath,
-        });
-    }
-    const pageModule = await server.ssrLoadModule(route.filePath);
-    const PageComponent = pageModule.default;
-    if (!PageComponent) {
-        throw new Error(`Page ${route.filePath} has no default export`);
-    }
-    // Collect page props
-    let pageProps = {};
-    if (typeof pageModule.getStaticProps === "function") {
-        const result = await pageModule.getStaticProps({ params });
-        if (result && "props" in result) {
-            pageProps = result.props;
-        }
-        if (result && "redirect" in result) {
-            // Static export can't handle redirects — write a meta redirect
-            const redirect = result.redirect;
-            return `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0;url=${escapeAttr(redirect.destination)}" /></head><body></body></html>`;
-        }
-        if (result && "notFound" in result && result.notFound) {
-            throw new Error(`Page ${urlPath} returned notFound: true`);
-        }
-    }
-    // Build element
-    const createElement = React.createElement;
-    let element;
-    if (AppComponent) {
-        element = createElement(AppComponent, {
-            Component: PageComponent,
-            pageProps,
-        });
-    }
-    else {
-        element = createElement(PageComponent, pageProps);
-    }
-    // Reset head collector and flush dynamic preloads
-    if (typeof headShim.resetSSRHead === "function") {
-        headShim.resetSSRHead();
-    }
-    if (typeof dynamicShim.flushPreloads === "function") {
-        await dynamicShim.flushPreloads();
-    }
-    // Render page body
-    const bodyHtml = await renderToStringAsync(element);
-    // Collect head tags
-    const ssrHeadHTML = typeof headShim.getSSRHeadHTML === "function" ? headShim.getSSRHeadHTML() : "";
-    // __NEXT_DATA__ for client hydration
-    const nextDataScript = `<script>window.__NEXT_DATA__ = ${safeJsonStringify({
-        props: { pageProps },
-        page: route.pattern,
-        query: params,
-        buildId: _config.buildId,
-    })}</script>`;
-    // Build HTML shell
-    let html;
-    if (DocumentComponent) {
-        const docElement = createElement(DocumentComponent);
-        // renderToReadableStream auto-prepends <!DOCTYPE html> when root is <html>
-        let docHtml = await renderToStringAsync(docElement);
-        docHtml = docHtml.replace("__NEXT_MAIN__", bodyHtml);
-        if (ssrHeadHTML) {
-            docHtml = docHtml.replace("</head>", `  ${ssrHeadHTML}\n</head>`);
-        }
-        docHtml = docHtml.replace("<!-- __NEXT_SCRIPTS__ -->", nextDataScript);
-        if (!docHtml.includes("__NEXT_DATA__")) {
-            docHtml = docHtml.replace("</body>", `  ${nextDataScript}\n</body>`);
-        }
-        html = docHtml;
-    }
-    else {
-        html = `<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  ${ssrHeadHTML}
-</head>
-<body>
-  <div id="__next">${bodyHtml}</div>
-  ${nextDataScript}
-</body>
-</html>`;
-    }
-    // Clear SSR context
-    if (typeof routerShim.setSSRContext === "function") {
-        routerShim.setSSRContext(null);
-    }
-    return html;
-}
-async function renderErrorPage(options) {
-    const { server, pagesDir, statusCode, AppComponent, DocumentComponent, headShim, fileMatcher } = options;
-    const candidates = statusCode === 404 ? ["404", "_error"] : statusCode === 500 ? ["500", "_error"] : ["_error"];
-    for (const candidate of candidates) {
-        const candidatePath = path.join(pagesDir, candidate);
-        if (!findFileWithExtensions(candidatePath, fileMatcher))
-            continue;
-        const errorModule = await server.ssrLoadModule(candidatePath);
-        const ErrorComponent = errorModule.default;
-        if (!ErrorComponent)
-            continue;
-        const createElement = React.createElement;
-        const errorProps = { statusCode };
-        let element;
-        if (AppComponent) {
-            element = createElement(AppComponent, {
-                Component: ErrorComponent,
-                pageProps: errorProps,
-            });
-        }
-        else {
-            element = createElement(ErrorComponent, errorProps);
-        }
-        if (typeof headShim.resetSSRHead === "function") {
-            headShim.resetSSRHead();
-        }
-        const bodyHtml = await renderToStringAsync(element);
-        let html;
-        if (DocumentComponent) {
-            const docElement = createElement(DocumentComponent);
-            let docHtml = await renderToStringAsync(docElement);
-            docHtml = docHtml.replace("__NEXT_MAIN__", bodyHtml);
-            docHtml = docHtml.replace("<!-- __NEXT_SCRIPTS__ -->", "");
-            html = docHtml;
-        }
-        else {
-            html = `<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-</head>
-<body>
-  <div id="__next">${bodyHtml}</div>
-</body>
-</html>`;
-        }
-        return html;
-    }
-    return null;
-}
+import { prerenderApp, prerenderPages } from "./prerender.js";
+//#region src/build/static-export.ts
 /**
- * Build a URL path from a route pattern and params.
- * E.g., "/posts/:id" + { id: "42" } → "/posts/42"
- * E.g., "/docs/:slug+" + { slug: ["a", "b"] } → "/docs/a/b"
- */
-function buildUrlFromParams(pattern, params) {
-    const parts = pattern.split("/").filter(Boolean);
-    const result = [];
-    for (const part of parts) {
-        if (part.endsWith("+") || part.endsWith("*")) {
-            // Catch-all: :slug+ or :slug*
-            const paramName = part.slice(1, -1);
-            const value = params[paramName];
-            if (Array.isArray(value)) {
-                result.push(...value);
-            }
-            else if (value) {
-                result.push(String(value));
-            }
-        }
-        else if (part.startsWith(":")) {
-            // Dynamic segment: :id
-            const paramName = part.slice(1);
-            const value = params[paramName];
-            result.push(String(value));
-        }
-        else {
-            result.push(part);
-        }
-    }
-    return "/" + result.join("/");
+* Convert a `PrerenderResult` into the legacy `StaticExportResult` shape.
+*/
+function toStaticExportResult(routes) {
+	const result = {
+		pageCount: 0,
+		files: [],
+		warnings: [],
+		errors: []
+	};
+	for (const r of routes) if (r.status === "rendered") {
+		result.pageCount++;
+		result.files.push(...r.outputFiles.filter((f) => f.endsWith(".html")));
+	} else if (r.status === "skipped") {
+		if (r.reason === "api") result.warnings.push(`API route ${r.route} skipped — API routes are not supported with output: 'export'`);
+	} else if (r.status === "error") result.errors.push({
+		route: r.route,
+		error: r.error
+	});
+	return result;
 }
 /**
- * Determine the output file path for a given URL.
- * Respects trailingSlash config.
- */
-function getOutputPath(urlPath, trailingSlash) {
-    if (urlPath === "/") {
-        return "index.html";
-    }
-    // Remove leading slash
-    const clean = urlPath.replace(/^\//, "");
-    if (trailingSlash) {
-        return `${clean}/index.html`;
-    }
-    return `${clean}.html`;
+* Run static export for Pages Router.
+*
+* Delegates to `prerenderPages()` in export mode.
+*/
+async function staticExportPages(options) {
+	return toStaticExportResult((await prerenderPages({
+		mode: "export",
+		pagesBundlePath: options.pagesBundlePath,
+		routes: options.routes,
+		apiRoutes: options.apiRoutes,
+		pagesDir: options.pagesDir,
+		outDir: options.outDir,
+		config: options.config
+	})).routes);
 }
 /**
- * Resolve parent dynamic segment params for a route.
- *
- * Implements Next.js's top-down params passing for generateStaticParams().
- * Walks up the route hierarchy to find parent dynamic segments that have their
- * own generateStaticParams. Collects parent params by calling each parent's
- * generateStaticParams in order, merging results top-down.
- *
- * Returns an array of parent param combinations. If empty, the child should
- * be called with `{ params: {} }` (bottom-up approach).
- */
-async function resolveParentParams(childRoute, allRoutes, server) {
-    // Extract the dynamic segment names from the pattern
-    const patternParts = childRoute.pattern.split("/").filter(Boolean);
-    const parentSegments = [];
-    // Walk pattern parts to find intermediate dynamic segments
-    // For /products/:category/:id, we look for a route or layout at /products/:category
-    // that has generateStaticParams
-    for (let i = 0; i < patternParts.length; i++) {
-        const part = patternParts[i];
-        if (!part.startsWith(":"))
-            continue;
-        // Check if this is not the last dynamic param (i.e., it's a parent segment)
-        const isLastDynamicPart = !patternParts.slice(i + 1).some((p) => p.startsWith(":"));
-        if (isLastDynamicPart)
-            break; // This is the child's own segment
-        // Build the prefix pattern up to this segment
-        const prefixPattern = "/" + patternParts.slice(0, i + 1).join("/");
-        // Find a route at this prefix that has generateStaticParams
-        const parentRoute = allRoutes.find((r) => r.pattern === prefixPattern);
-        if (parentRoute?.pagePath) {
-            try {
-                const parentModule = await server.ssrLoadModule(parentRoute.pagePath);
-                if (typeof parentModule.generateStaticParams === "function") {
-                    const paramName = part.replace(/^:/, "").replace(/[+*]$/, "");
-                    parentSegments.push({
-                        params: [paramName],
-                        generateStaticParams: parentModule.generateStaticParams,
-                    });
-                }
-            }
-            catch {
-                // Skip — parent module couldn't be loaded
-            }
-        }
-    }
-    if (parentSegments.length === 0)
-        return [];
-    // Top-down resolution: call each parent's generateStaticParams in order,
-    // accumulating params
-    let currentParams = [{}];
-    for (const segment of parentSegments) {
-        const nextParams = [];
-        for (const parentParams of currentParams) {
-            const results = await segment.generateStaticParams({ params: parentParams });
-            if (Array.isArray(results)) {
-                for (const result of results) {
-                    nextParams.push({ ...parentParams, ...result });
-                }
-            }
-        }
-        currentParams = nextParams;
-    }
-    return currentParams;
-}
-/**
- * Run static export for App Router.
- *
- * Fetches each route from a running dev server and writes the HTML to disk.
- * For dynamic routes, calls generateStaticParams() to expand all paths.
- */
-export async function staticExportApp(options) {
-    const { baseUrl, routes, server, outDir, config } = options;
-    const result = {
-        pageCount: 0,
-        files: [],
-        warnings: [],
-        errors: [],
-    };
-    fs.mkdirSync(outDir, { recursive: true });
-    // Collect all URLs to render
-    const urlsToRender = [];
-    for (const route of routes) {
-        // Skip API route handlers — not supported in static export
-        if (route.routePath && !route.pagePath) {
-            result.warnings.push(`Route handler ${route.pattern} skipped — API routes are not supported with output: 'export'`);
-            continue;
-        }
-        if (!route.pagePath)
-            continue;
-        if (route.isDynamic) {
-            // Dynamic route — must have generateStaticParams
-            try {
-                const pageModule = await server.ssrLoadModule(route.pagePath);
-                if (typeof pageModule.generateStaticParams !== "function") {
-                    result.errors.push({
-                        route: route.pattern,
-                        error: `Dynamic route requires generateStaticParams() with output: 'export'`,
-                    });
-                    continue;
-                }
-                // Resolve parent dynamic segments for top-down params passing.
-                // Find all other routes whose patterns are prefixes of this route's pattern
-                // and that have dynamic params, then collect their generateStaticParams.
-                const parentParamSets = await resolveParentParams(route, routes, server);
-                let paramSets;
-                if (parentParamSets.length > 0) {
-                    // Top-down: call child's generateStaticParams for each parent param set
-                    paramSets = [];
-                    for (const parentParams of parentParamSets) {
-                        const childResults = await pageModule.generateStaticParams({ params: parentParams });
-                        if (Array.isArray(childResults)) {
-                            for (const childParams of childResults) {
-                                paramSets.push({ ...parentParams, ...childParams });
-                            }
-                        }
-                    }
-                }
-                else {
-                    // Bottom-up: no parent params, call with empty params
-                    paramSets = await pageModule.generateStaticParams({ params: {} });
-                }
-                if (!Array.isArray(paramSets) || paramSets.length === 0) {
-                    result.warnings.push(`generateStaticParams() for ${route.pattern} returned empty array — no pages generated`);
-                    continue;
-                }
-                for (const params of paramSets) {
-                    const urlPath = buildUrlFromParams(route.pattern, params);
-                    urlsToRender.push(urlPath);
-                }
-            }
-            catch (e) {
-                result.errors.push({
-                    route: route.pattern,
-                    error: `Failed to call generateStaticParams(): ${e.message}`,
-                });
-            }
-        }
-        else {
-            // Static route
-            urlsToRender.push(route.pattern);
-        }
-    }
-    // Fetch each URL from the dev server and write HTML
-    for (const urlPath of urlsToRender) {
-        try {
-            const res = await fetch(`${baseUrl}${urlPath}`);
-            if (!res.ok) {
-                result.errors.push({
-                    route: urlPath,
-                    error: `Server returned ${res.status}`,
-                });
-                continue;
-            }
-            const html = await res.text();
-            const outputPath = getOutputPath(urlPath, config.trailingSlash);
-            const fullPath = path.join(outDir, outputPath);
-            fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-            fs.writeFileSync(fullPath, html, "utf-8");
-            result.files.push(outputPath);
-            result.pageCount++;
-        }
-        catch (e) {
-            result.errors.push({
-                route: urlPath,
-                error: e.message,
-            });
-        }
-    }
-    // Render 404 page
-    try {
-        const res = await fetch(`${baseUrl}/__nonexistent_page_for_404__`);
-        if (res.status === 404) {
-            const html = await res.text();
-            if (html.length > 0) {
-                const fullPath = path.join(outDir, "404.html");
-                fs.writeFileSync(fullPath, html, "utf-8");
-                result.files.push("404.html");
-                result.pageCount++;
-            }
-        }
-    }
-    catch {
-        // No custom 404, skip
-    }
-    return result;
-}
+* Run static export for App Router.
+*
+* Delegates to `prerenderApp()` in export mode.
+*/
+async function staticExportApp(options) {
+	return toStaticExportResult((await prerenderApp({
+		mode: "export",
+		rscBundlePath: options.rscBundlePath,
+		routes: options.routes,
+		outDir: options.outDir,
+		config: options.config
+	})).routes);
+}
+//#endregion
+export { staticExportApp, staticExportPages };
+
 //# sourceMappingURL=static-export.js.map