495 lines
18 KiB
Plaintext
495 lines
18 KiB
Plaintext
import { bgGreen, black, blue, bold, dim, green, magenta, red } from "kleur/colors";
|
|
import fs from "node:fs";
|
|
import os from "node:os";
|
|
import { fileURLToPath } from "node:url";
|
|
import PQueue from "p-queue";
|
|
import {
|
|
generateImagesForPath,
|
|
getStaticImageList,
|
|
prepareAssetsGenerationEnv
|
|
} from "../../assets/build/generate.js";
|
|
import { hasPrerenderedPages } from "../../core/build/internal.js";
|
|
import {
|
|
isRelativePath,
|
|
joinPaths,
|
|
prependForwardSlash,
|
|
removeLeadingForwardSlash,
|
|
removeTrailingForwardSlash
|
|
} from "../../core/path.js";
|
|
import { createI18nMiddleware, i18nPipelineHook } from "../../i18n/middleware.js";
|
|
import { runHookBuildGenerated } from "../../integrations/index.js";
|
|
import { getOutputDirectory, isServerLikeOutput } from "../../prerender/utils.js";
|
|
import { PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
|
|
import { AstroError, AstroErrorData } from "../errors/index.js";
|
|
import { sequence } from "../middleware/index.js";
|
|
import { routeIsFallback } from "../redirects/helpers.js";
|
|
import {
|
|
RedirectSinglePageBuiltModule,
|
|
getRedirectLocationOrThrow,
|
|
routeIsRedirect
|
|
} from "../redirects/index.js";
|
|
import { createRenderContext } from "../render/index.js";
|
|
import { callGetStaticPaths } from "../render/route-cache.js";
|
|
import {
|
|
createAssetLink,
|
|
createModuleScriptsSet,
|
|
createStylesheetElementSet
|
|
} from "../render/ssr-element.js";
|
|
import { createRequest } from "../request.js";
|
|
import { matchRoute } from "../routing/match.js";
|
|
import { getOutputFilename } from "../util.js";
|
|
import { BuildPipeline } from "./buildPipeline.js";
|
|
import { getOutDirWithinCwd, getOutFile, getOutFolder } from "./common.js";
|
|
import {
|
|
cssOrder,
|
|
getEntryFilePathFromComponentPath,
|
|
getPageDataByComponent,
|
|
mergeInlineCss
|
|
} from "./internal.js";
|
|
import { getTimeStat, shouldAppendForwardSlash } from "./util.js";
|
|
function createEntryURL(filePath, outFolder) {
|
|
return new URL("./" + filePath + `?time=${Date.now()}`, outFolder);
|
|
}
|
|
async function getEntryForRedirectRoute(route, internals, outFolder) {
|
|
if (route.type !== "redirect") {
|
|
throw new Error(`Expected a redirect route.`);
|
|
}
|
|
if (route.redirectRoute) {
|
|
const filePath = getEntryFilePathFromComponentPath(internals, route.redirectRoute.component);
|
|
if (filePath) {
|
|
const url = createEntryURL(filePath, outFolder);
|
|
const ssrEntryPage = await import(url.toString());
|
|
return ssrEntryPage;
|
|
}
|
|
}
|
|
return RedirectSinglePageBuiltModule;
|
|
}
|
|
async function getEntryForFallbackRoute(route, internals, outFolder) {
|
|
if (route.type !== "fallback") {
|
|
throw new Error(`Expected a redirect route.`);
|
|
}
|
|
if (route.redirectRoute) {
|
|
const filePath = getEntryFilePathFromComponentPath(internals, route.redirectRoute.component);
|
|
if (filePath) {
|
|
const url = createEntryURL(filePath, outFolder);
|
|
const ssrEntryPage = await import(url.toString());
|
|
return ssrEntryPage;
|
|
}
|
|
}
|
|
return RedirectSinglePageBuiltModule;
|
|
}
|
|
function rootRelativeFacadeId(facadeId, settings) {
|
|
return facadeId.slice(fileURLToPath(settings.config.root).length);
|
|
}
|
|
function chunkIsPage(settings, output, internals) {
|
|
if (output.type !== "chunk") {
|
|
return false;
|
|
}
|
|
const chunk = output;
|
|
if (chunk.facadeModuleId) {
|
|
const facadeToEntryId = prependForwardSlash(
|
|
rootRelativeFacadeId(chunk.facadeModuleId, settings)
|
|
);
|
|
return internals.entrySpecifierToBundleMap.has(facadeToEntryId);
|
|
}
|
|
return false;
|
|
}
|
|
async function generatePages(opts, internals) {
|
|
const generatePagesTimer = performance.now();
|
|
const ssr = isServerLikeOutput(opts.settings.config);
|
|
let manifest;
|
|
if (ssr) {
|
|
manifest = await BuildPipeline.retrieveManifest(opts, internals);
|
|
} else {
|
|
const baseDirectory = getOutputDirectory(opts.settings.config);
|
|
const renderersEntryUrl = new URL("renderers.mjs", baseDirectory);
|
|
const renderers = await import(renderersEntryUrl.toString());
|
|
manifest = createBuildManifest(
|
|
opts.settings,
|
|
internals,
|
|
renderers.renderers
|
|
);
|
|
}
|
|
const pipeline = new BuildPipeline(opts, internals, manifest);
|
|
const outFolder = ssr ? opts.settings.config.build.server : getOutDirWithinCwd(opts.settings.config.outDir);
|
|
const logger = pipeline.getLogger();
|
|
if (ssr && !hasPrerenderedPages(internals)) {
|
|
delete globalThis?.astroAsset?.addStaticImage;
|
|
return;
|
|
}
|
|
const verb = ssr ? "prerendering" : "generating";
|
|
logger.info("SKIP_FORMAT", `
|
|
${bgGreen(black(` ${verb} static routes `))}`);
|
|
const builtPaths = /* @__PURE__ */ new Set();
|
|
const pagesToGenerate = pipeline.retrieveRoutesToGenerate();
|
|
if (ssr) {
|
|
for (const [pageData, filePath] of pagesToGenerate) {
|
|
if (pageData.route.prerender) {
|
|
const ssrEntryURLPage = createEntryURL(filePath, outFolder);
|
|
const ssrEntryPage = await import(ssrEntryURLPage.toString());
|
|
if (opts.settings.adapter?.adapterFeatures?.functionPerRoute) {
|
|
const ssrEntry = ssrEntryPage?.pageModule;
|
|
if (ssrEntry) {
|
|
await generatePage(pageData, ssrEntry, builtPaths, pipeline);
|
|
} else {
|
|
throw new Error(
|
|
`Unable to find the manifest for the module ${ssrEntryURLPage.toString()}. This is unexpected and likely a bug in Astro, please report.`
|
|
);
|
|
}
|
|
} else {
|
|
const ssrEntry = ssrEntryPage;
|
|
await generatePage(pageData, ssrEntry, builtPaths, pipeline);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (const [pageData, filePath] of pagesToGenerate) {
|
|
if (routeIsRedirect(pageData.route)) {
|
|
const entry = await getEntryForRedirectRoute(pageData.route, internals, outFolder);
|
|
await generatePage(pageData, entry, builtPaths, pipeline);
|
|
} else if (routeIsFallback(pageData.route)) {
|
|
const entry = await getEntryForFallbackRoute(pageData.route, internals, outFolder);
|
|
await generatePage(pageData, entry, builtPaths, pipeline);
|
|
} else {
|
|
const ssrEntryURLPage = createEntryURL(filePath, outFolder);
|
|
const entry = await import(ssrEntryURLPage.toString());
|
|
await generatePage(pageData, entry, builtPaths, pipeline);
|
|
}
|
|
}
|
|
}
|
|
logger.info(
|
|
null,
|
|
green(`\u2713 Completed in ${getTimeStat(generatePagesTimer, performance.now())}.
|
|
`)
|
|
);
|
|
const staticImageList = getStaticImageList();
|
|
if (staticImageList.size) {
|
|
logger.info("SKIP_FORMAT", `${bgGreen(black(` generating optimized images `))}`);
|
|
const totalCount = Array.from(staticImageList.values()).map((x) => x.transforms.size).reduce((a, b) => a + b, 0);
|
|
const cpuCount = os.cpus().length;
|
|
const assetsCreationEnvironment = await prepareAssetsGenerationEnv(pipeline, totalCount);
|
|
const queue = new PQueue({ concurrency: Math.max(cpuCount, 1) });
|
|
const assetsTimer = performance.now();
|
|
for (const [originalPath, transforms] of staticImageList) {
|
|
await generateImagesForPath(originalPath, transforms, assetsCreationEnvironment, queue);
|
|
}
|
|
await queue.onIdle();
|
|
const assetsTimeEnd = performance.now();
|
|
logger.info(null, green(`\u2713 Completed in ${getTimeStat(assetsTimer, assetsTimeEnd)}.
|
|
`));
|
|
delete globalThis?.astroAsset?.addStaticImage;
|
|
}
|
|
await runHookBuildGenerated({
|
|
config: opts.settings.config,
|
|
logger: pipeline.getLogger()
|
|
});
|
|
}
|
|
async function generatePage(pageData, ssrEntry, builtPaths, pipeline) {
|
|
const logger = pipeline.getLogger();
|
|
const config = pipeline.getConfig();
|
|
const pageModulePromise = ssrEntry.page;
|
|
const onRequest = ssrEntry.onRequest;
|
|
const pageInfo = getPageDataByComponent(pipeline.getInternals(), pageData.route.component);
|
|
const styles = pageData.styles.sort(cssOrder).map(({ sheet }) => sheet).reduce(mergeInlineCss, []);
|
|
const linkIds = [];
|
|
const scripts = pageInfo?.hoistedScript ?? null;
|
|
const i18nMiddleware = createI18nMiddleware(
|
|
pipeline.getManifest().i18n,
|
|
pipeline.getManifest().base,
|
|
pipeline.getManifest().trailingSlash,
|
|
pipeline.getManifest().buildFormat
|
|
);
|
|
if (config.i18n && i18nMiddleware) {
|
|
if (onRequest) {
|
|
pipeline.setMiddlewareFunction(sequence(i18nMiddleware, onRequest));
|
|
} else {
|
|
pipeline.setMiddlewareFunction(i18nMiddleware);
|
|
}
|
|
pipeline.onBeforeRenderRoute(i18nPipelineHook);
|
|
} else if (onRequest) {
|
|
pipeline.setMiddlewareFunction(onRequest);
|
|
}
|
|
if (!pageModulePromise) {
|
|
throw new Error(
|
|
`Unable to find the module for ${pageData.component}. This is unexpected and likely a bug in Astro, please report.`
|
|
);
|
|
}
|
|
const pageModule = await pageModulePromise();
|
|
const generationOptions = {
|
|
pageData,
|
|
linkIds,
|
|
scripts,
|
|
styles,
|
|
mod: pageModule
|
|
};
|
|
for (const route of eachRouteInRouteData(pageData)) {
|
|
const icon = route.type === "page" || route.type === "redirect" || route.type === "fallback" ? green("\u25B6") : magenta("\u03BB");
|
|
logger.info(null, `${icon} ${getPrettyRouteName(route)}`);
|
|
const paths = await getPathsForRoute(route, pageModule, pipeline, builtPaths);
|
|
let timeStart = performance.now();
|
|
let prevTimeEnd = timeStart;
|
|
for (let i = 0; i < paths.length; i++) {
|
|
const path = paths[i];
|
|
pipeline.getEnvironment().logger.debug("build", `Generating: ${path}`);
|
|
const filePath = getOutputFilename(pipeline.getConfig(), path, pageData.route.type);
|
|
const lineIcon = i === paths.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
|
|
logger.info(null, ` ${blue(lineIcon)} ${dim(filePath)}`, false);
|
|
await generatePath(path, pipeline, generationOptions, route);
|
|
const timeEnd = performance.now();
|
|
const timeChange = getTimeStat(prevTimeEnd, timeEnd);
|
|
const timeIncrease = `(+${timeChange})`;
|
|
logger.info("SKIP_FORMAT", ` ${dim(timeIncrease)}`);
|
|
prevTimeEnd = timeEnd;
|
|
}
|
|
}
|
|
}
|
|
function* eachRouteInRouteData(data) {
|
|
yield data.route;
|
|
for (const fallbackRoute of data.route.fallbackRoutes) {
|
|
yield fallbackRoute;
|
|
}
|
|
}
|
|
async function getPathsForRoute(route, mod, pipeline, builtPaths) {
|
|
const opts = pipeline.getStaticBuildOptions();
|
|
const logger = pipeline.getLogger();
|
|
let paths = [];
|
|
if (route.pathname) {
|
|
paths.push(route.pathname);
|
|
builtPaths.add(route.pathname);
|
|
for (const virtualRoute of route.fallbackRoutes) {
|
|
if (virtualRoute.pathname) {
|
|
paths.push(virtualRoute.pathname);
|
|
builtPaths.add(virtualRoute.pathname);
|
|
}
|
|
}
|
|
} else {
|
|
const staticPaths = await callGetStaticPaths({
|
|
mod,
|
|
route,
|
|
routeCache: opts.routeCache,
|
|
logger,
|
|
ssr: isServerLikeOutput(opts.settings.config)
|
|
}).catch((err) => {
|
|
logger.debug("build", `\u251C\u2500\u2500 ${bold(red("\u2717"))} ${route.component}`);
|
|
throw err;
|
|
});
|
|
const label = staticPaths.length === 1 ? "page" : "pages";
|
|
logger.debug(
|
|
"build",
|
|
`\u251C\u2500\u2500 ${bold(green("\u2714"))} ${route.component} \u2192 ${magenta(`[${staticPaths.length} ${label}]`)}`
|
|
);
|
|
paths = staticPaths.map((staticPath) => {
|
|
try {
|
|
return route.generate(staticPath.params);
|
|
} catch (e) {
|
|
if (e instanceof TypeError) {
|
|
throw getInvalidRouteSegmentError(e, route, staticPath);
|
|
}
|
|
throw e;
|
|
}
|
|
}).filter((staticPath) => {
|
|
if (!builtPaths.has(removeTrailingForwardSlash(staticPath))) {
|
|
return true;
|
|
}
|
|
const matchedRoute = matchRoute(staticPath, opts.manifest);
|
|
return matchedRoute === route;
|
|
});
|
|
for (const staticPath of paths) {
|
|
builtPaths.add(removeTrailingForwardSlash(staticPath));
|
|
}
|
|
}
|
|
return paths;
|
|
}
|
|
function getInvalidRouteSegmentError(e, route, staticPath) {
|
|
const invalidParam = e.message.match(/^Expected "([^"]+)"/)?.[1];
|
|
const received = invalidParam ? staticPath.params[invalidParam] : void 0;
|
|
let hint = "Learn about dynamic routes at https://docs.astro.build/en/core-concepts/routing/#dynamic-routes";
|
|
if (invalidParam && typeof received === "string") {
|
|
const matchingSegment = route.segments.find(
|
|
(segment) => segment[0]?.content === invalidParam
|
|
)?.[0];
|
|
const mightBeMissingSpread = matchingSegment?.dynamic && !matchingSegment?.spread;
|
|
if (mightBeMissingSpread) {
|
|
hint = `If the param contains slashes, try using a rest parameter: **[...${invalidParam}]**. Learn more at https://docs.astro.build/en/core-concepts/routing/#dynamic-routes`;
|
|
}
|
|
}
|
|
return new AstroError({
|
|
...AstroErrorData.InvalidDynamicRoute,
|
|
message: invalidParam ? AstroErrorData.InvalidDynamicRoute.message(
|
|
route.route,
|
|
JSON.stringify(invalidParam),
|
|
JSON.stringify(received)
|
|
) : `Generated path for ${route.route} is invalid.`,
|
|
hint
|
|
});
|
|
}
|
|
function addPageName(pathname, opts) {
|
|
const trailingSlash = opts.settings.config.trailingSlash;
|
|
const buildFormat = opts.settings.config.build.format;
|
|
const pageName = shouldAppendForwardSlash(trailingSlash, buildFormat) ? pathname.replace(/\/?$/, "/").replace(/^\//, "") : pathname.replace(/^\//, "");
|
|
opts.pageNames.push(pageName);
|
|
}
|
|
function getUrlForPath(pathname, base, origin, format, routeType) {
|
|
const ending = format === "directory" ? "/" : ".html";
|
|
let buildPathname;
|
|
if (pathname === "/" || pathname === "") {
|
|
buildPathname = base;
|
|
} else if (routeType === "endpoint") {
|
|
const buildPathRelative = removeLeadingForwardSlash(pathname);
|
|
buildPathname = joinPaths(base, buildPathRelative);
|
|
} else {
|
|
const buildPathRelative = removeTrailingForwardSlash(removeLeadingForwardSlash(pathname)) + ending;
|
|
buildPathname = joinPaths(base, buildPathRelative);
|
|
}
|
|
const url = new URL(buildPathname, origin);
|
|
return url;
|
|
}
|
|
async function generatePath(pathname, pipeline, gopts, route) {
|
|
const { mod, scripts: hoistedScripts, styles: _styles } = gopts;
|
|
const manifest = pipeline.getManifest();
|
|
pipeline.getEnvironment().logger.debug("build", `Generating: ${pathname}`);
|
|
const links = /* @__PURE__ */ new Set();
|
|
const scripts = createModuleScriptsSet(
|
|
hoistedScripts ? [hoistedScripts] : [],
|
|
manifest.base,
|
|
manifest.assetsPrefix
|
|
);
|
|
const styles = createStylesheetElementSet(_styles, manifest.base, manifest.assetsPrefix);
|
|
if (pipeline.getSettings().scripts.some((script) => script.stage === "page")) {
|
|
const hashedFilePath = pipeline.getInternals().entrySpecifierToBundleMap.get(PAGE_SCRIPT_ID);
|
|
if (typeof hashedFilePath !== "string") {
|
|
throw new Error(`Cannot find the built path for ${PAGE_SCRIPT_ID}`);
|
|
}
|
|
const src = createAssetLink(hashedFilePath, manifest.base, manifest.assetsPrefix);
|
|
scripts.add({
|
|
props: { type: "module", src },
|
|
children: ""
|
|
});
|
|
}
|
|
for (const script of pipeline.getSettings().scripts) {
|
|
if (script.stage === "head-inline") {
|
|
scripts.add({
|
|
props: {},
|
|
children: script.content
|
|
});
|
|
}
|
|
}
|
|
if (route.type === "page") {
|
|
addPageName(pathname, pipeline.getStaticBuildOptions());
|
|
}
|
|
const ssr = isServerLikeOutput(pipeline.getConfig());
|
|
const url = getUrlForPath(
|
|
pathname,
|
|
pipeline.getConfig().base,
|
|
pipeline.getStaticBuildOptions().origin,
|
|
pipeline.getConfig().build.format,
|
|
route.type
|
|
);
|
|
const request = createRequest({
|
|
url,
|
|
headers: new Headers(),
|
|
logger: pipeline.getLogger(),
|
|
ssr
|
|
});
|
|
const i18n = pipeline.getConfig().i18n;
|
|
const renderContext = await createRenderContext({
|
|
pathname,
|
|
request,
|
|
componentMetadata: manifest.componentMetadata,
|
|
scripts,
|
|
styles,
|
|
links,
|
|
route,
|
|
env: pipeline.getEnvironment(),
|
|
mod,
|
|
locales: i18n?.locales,
|
|
routing: i18n?.routing,
|
|
defaultLocale: i18n?.defaultLocale
|
|
});
|
|
let body;
|
|
let response;
|
|
try {
|
|
response = await pipeline.renderRoute(renderContext, mod);
|
|
} catch (err) {
|
|
if (!AstroError.is(err) && !err.id && typeof err === "object") {
|
|
err.id = route.component;
|
|
}
|
|
throw err;
|
|
}
|
|
if (response.status >= 300 && response.status < 400) {
|
|
if (!pipeline.getConfig().build.redirects) {
|
|
return;
|
|
}
|
|
const locationSite = getRedirectLocationOrThrow(response.headers);
|
|
const siteURL = pipeline.getConfig().site;
|
|
const location = siteURL ? new URL(locationSite, siteURL) : locationSite;
|
|
const fromPath = new URL(renderContext.request.url).pathname;
|
|
const delay = response.status === 302 ? 2 : 0;
|
|
body = `<!doctype html>
|
|
<title>Redirecting to: ${location}</title>
|
|
<meta http-equiv="refresh" content="${delay};url=${location}">
|
|
<meta name="robots" content="noindex">
|
|
<link rel="canonical" href="${location}">
|
|
<body>
|
|
<a href="${location}">Redirecting from <code>${fromPath}</code> to <code>${location}</code></a>
|
|
</body>`;
|
|
if (pipeline.getConfig().compressHTML === true) {
|
|
body = body.replaceAll("\n", "");
|
|
}
|
|
if (route.type !== "redirect") {
|
|
route.redirect = location.toString();
|
|
}
|
|
} else {
|
|
if (!response.body)
|
|
return;
|
|
body = Buffer.from(await response.arrayBuffer());
|
|
}
|
|
const outFolder = getOutFolder(pipeline.getConfig(), pathname, route.type);
|
|
const outFile = getOutFile(pipeline.getConfig(), outFolder, pathname, route.type);
|
|
route.distURL = outFile;
|
|
await fs.promises.mkdir(outFolder, { recursive: true });
|
|
await fs.promises.writeFile(outFile, body);
|
|
}
|
|
function getPrettyRouteName(route) {
|
|
if (isRelativePath(route.component)) {
|
|
return route.route;
|
|
} else if (route.component.includes("node_modules/")) {
|
|
return route.component.match(/.*node_modules\/(.+)/)?.[1] ?? route.component;
|
|
} else {
|
|
return route.component;
|
|
}
|
|
}
|
|
function createBuildManifest(settings, internals, renderers) {
|
|
let i18nManifest = void 0;
|
|
if (settings.config.i18n) {
|
|
i18nManifest = {
|
|
fallback: settings.config.i18n.fallback,
|
|
routing: settings.config.i18n.routing,
|
|
defaultLocale: settings.config.i18n.defaultLocale,
|
|
locales: settings.config.i18n.locales
|
|
};
|
|
}
|
|
return {
|
|
trailingSlash: settings.config.trailingSlash,
|
|
assets: /* @__PURE__ */ new Set(),
|
|
entryModules: Object.fromEntries(internals.entrySpecifierToBundleMap.entries()),
|
|
routes: [],
|
|
adapterName: "",
|
|
clientDirectives: settings.clientDirectives,
|
|
compressHTML: settings.config.compressHTML,
|
|
renderers,
|
|
base: settings.config.base,
|
|
assetsPrefix: settings.config.build.assetsPrefix,
|
|
site: settings.config.site ? new URL(settings.config.base, settings.config.site).toString() : settings.config.site,
|
|
componentMetadata: internals.componentMetadata,
|
|
i18n: i18nManifest,
|
|
buildFormat: settings.config.build.format
|
|
};
|
|
}
|
|
export {
|
|
chunkIsPage,
|
|
createBuildManifest,
|
|
generatePages,
|
|
rootRelativeFacadeId
|
|
};
|