one
Version:
One is a React framework for web, iOS, and Android apps.
959 lines (943 loc) • 36.6 kB
JavaScript
import { createRequire } from "node:module";
import { cpus } from "node:os";
import Path, { join, posix, relative, resolve } from "node:path";
import { resolvePath } from "@vxrn/resolve";
import FSExtra from "fs-extra";
import MicroMatch from "micromatch";
import { build as build$1, createBuilder, mergeConfig, normalizePath } from "vite";
import { build as build$2, getOptimizeDeps, rollupRemoveUnusedImportsPlugin } from "vxrn";
import * as constants from "../constants.mjs";
import { setServerGlobals } from "../server/setServerGlobals.mjs";
import { environmentGuardPlugin } from "../vite/plugins/environmentGuardPlugin.mjs";
import { writeBuildOutputPointer } from "../utils/buildOutputPointer.mjs";
import { getPathnameFromFilePath } from "../utils/getPathnameFromFilePath.mjs";
import { getRouterRootFromOneOptions } from "../utils/getRouterRootFromOneOptions.mjs";
import { isRolldown } from "../utils/isRolldown.mjs";
import { toAbsolute } from "../utils/toAbsolute.mjs";
import { buildVercelOutputDirectory } from "../vercel/build/buildVercelOutputDirectory.mjs";
import { createCloudflareWranglerConfig, getCloudflareProjectName, isPlainObject, loadUserWranglerConfig } from "../vite/cloudflareWranglerConfig.mjs";
import { getManifest } from "../vite/getManifest.mjs";
import { loadUserOneOptions } from "../vite/loadConfig.mjs";
import { runWithAsyncLocalContext } from "../vite/one-server-only.mjs";
import { buildPage, printBuildTimings } from "./buildPage.mjs";
import { checkNodeVersion } from "./checkNodeVersion.mjs";
import { getWorkerPool, terminateWorkerPool } from "./workerPool.mjs";
import { generateSitemap } from "./generateSitemap.mjs";
import { labelProcess } from "./label-process.mjs";
import { getRouteExports } from "./serverRouteModules.mjs";
import { pLimit } from "../utils/pLimit.mjs";
import { getCriticalCSSOutputPaths } from "../vite/plugins/criticalCSSPlugin.mjs";
import { absorbedPackageAliases } from "../utils/absorbedPackages.mjs";
import { formatErrorSafely, installPrepareStackTraceGuard } from "./install-error-handlers.mjs";
const { ensureDir, writeJSON } = FSExtra;
function normalizeDeploy(deploy) {
if (!deploy) return void 0;
if (typeof deploy === "string") return { target: deploy };
return deploy;
}
const CLOUDFLARE_DEPLOY_WRANGLER_RULES = [{
type: "ESModule",
globs: ["assets/**/*.js", "assets/**/*.mjs"]
}];
function omitEmptyJsonValues(value) {
if (Array.isArray(value)) {
const items = value.map((item) => omitEmptyJsonValues(item)).filter((item) => item !== void 0);
return items.length > 0 ? items : void 0;
}
if (isPlainObject(value)) {
const entries = Object.entries(value).map(([key, item]) => [key, omitEmptyJsonValues(item)]).filter((entry) => entry[1] !== void 0);
return entries.length > 0 ? Object.fromEntries(entries) : void 0;
}
return value;
}
async function finalizeCloudflareWranglerDeployConfig(configPath) {
const parsed = JSON.parse(await FSExtra.readFile(configPath, "utf-8"));
if (!isPlainObject(parsed)) {
throw new Error(`Expected ${relative(process.cwd(), configPath)} to contain a JSON object`);
}
parsed.rules = CLOUDFLARE_DEPLOY_WRANGLER_RULES;
const config = omitEmptyJsonValues(parsed);
if (!isPlainObject(config)) {
throw new Error(`Expected ${relative(process.cwd(), configPath)} to contain deploy config`);
}
await FSExtra.writeFile(configPath, `${JSON.stringify(config, null, 2)}
`);
}
process.env.ONE_CACHE_KEY = constants.CACHE_KEY;
function shouldUseWorkers(oneOptions) {
if (process.env.ONE_BUILD_WORKERS === "0") return false;
if (process.env.ONE_BUILD_WORKERS === "1") return true;
return oneOptions?.build?.workers !== false;
}
installPrepareStackTraceGuard();
let buildErrorHandlersInstalled = false;
function installBuildErrorHandlers() {
if (buildErrorHandlersInstalled) return;
buildErrorHandlersInstalled = true;
process.on("uncaughtException", (err) => {
try {
process.stderr.write(`[one build] uncaught exception
${formatErrorSafely(err)}
`);
} catch {}
process.exit(1);
});
process.on("unhandledRejection", (reason) => {
try {
process.stderr.write(`[one build] unhandled rejection
${formatErrorSafely(reason)}
`);
} catch {}
process.exit(1);
});
}
const HOOK_KEYS = [
"resolveId",
"load",
"transform",
"renderChunk",
"generateBundle",
"writeBundle",
"buildStart",
"buildEnd",
"moduleParsed"
];
function clonePluginHooks(config) {
if (!config.plugins) return config;
return {
...config,
plugins: config.plugins.map((p) => {
if (!p || typeof p !== "object") return p;
const cloned = { ...p };
for (const key of HOOK_KEYS) {
if (cloned[key] && typeof cloned[key] === "object" && "handler" in cloned[key]) {
cloned[key] = { ...cloned[key] };
}
}
return cloned;
})
};
}
async function build(args) {
installBuildErrorHandlers();
process.env.IS_VXRN_CLI = "true";
if (!process.env.NODE_ENV) {
process.env.NODE_ENV = "production";
} else if (process.env.NODE_ENV !== "production") {
console.warn(`
\u26A0\uFE0F Warning: NODE_ENV is set to "${process.env.NODE_ENV}" (builds default to "production")
`);
}
labelProcess("build");
checkNodeVersion();
setServerGlobals();
const { oneOptions, config: viteLoadedConfig } = await loadUserOneOptions("build");
const routerRoot = getRouterRootFromOneOptions(oneOptions);
const configuredBuildConcurrency = process.env.ONE_BUILD_CONCURRENCY ?? oneOptions.build?.concurrency;
const buildConcurrency = configuredBuildConcurrency === void 0 ? Math.max(1, Math.min(cpus().length, 8)) : Number(configuredBuildConcurrency);
if (!Number.isInteger(buildConcurrency) || buildConcurrency < 1) {
throw new Error(`build.concurrency must be a positive integer, received ${JSON.stringify(configuredBuildConcurrency)}`);
}
if (oneOptions.web?.defaultRenderMode) {
process.env.ONE_DEFAULT_RENDER_MODE = oneOptions.web.defaultRenderMode;
}
const deployConfig = normalizeDeploy(oneOptions.web?.deploy);
if (!process.env.ONE_SERVER_URL && deployConfig) {
const url = deployConfig.url ?? (deployConfig.target === "cloudflare" ? `https://${await getCloudflareProjectName(process.cwd())}.workers.dev` : void 0);
if (url) {
process.env.ONE_SERVER_URL = url;
console.info(`
\u2601\uFE0F ONE_SERVER_URL: ${url}
`);
}
}
const outDir = viteLoadedConfig?.config?.build?.outDir ?? "dist";
const manifest = getManifest({
routerRoot,
ignoredRouteFiles: oneOptions.router?.ignoredRouteFiles
});
const serverOutputFormat = oneOptions.build?.server === false ? "esm" : oneOptions.build?.server?.outputFormat ?? "esm";
const buildStartTime = performance.now();
const vxrnOutput = await build$2({
skipEnv: args.skipEnv ?? oneOptions.skipEnv,
server: oneOptions.server,
build: {
analyze: true,
server: oneOptions.build?.server === false ? false : { outputFormat: serverOutputFormat }
}
}, args);
const bundleTime = performance.now() - buildStartTime;
console.info(`
\u23F1\uFE0F vite bundle: ${(bundleTime / 1e3).toFixed(2)}s
`);
if (!vxrnOutput || args.platform !== "web") {
return;
}
const { options } = vxrnOutput;
const { optimizeDeps } = getOptimizeDeps("build");
const { rolldownOptions: _rolldownOptions, ...optimizeDepsNoRolldown } = optimizeDeps;
const serverOpts = oneOptions.build?.server;
const isUnified = typeof serverOpts === "object" && serverOpts !== null && serverOpts.unified === true;
let baseForApi = isUnified ? clonePluginHooks(vxrnOutput.serverBuildConfig ?? vxrnOutput.webBuildConfig) : clonePluginHooks(vxrnOutput.webBuildConfig);
if (isUnified) {
const clone = {
...baseForApi,
build: baseForApi.build ? { ...baseForApi.build } : void 0,
plugins: baseForApi.plugins ? baseForApi.plugins.filter((p) => p && typeof p === "object" && p.name !== "omit-api-routes") : void 0
};
if (clone.build && clone.build.rolldownOptions) {
const ro = { ...clone.build.rolldownOptions };
delete ro.input;
clone.build.rolldownOptions = ro;
}
if (clone.build) {
delete clone.build.outDir;
}
baseForApi = clone;
}
const apiBuildConfig = mergeConfig(baseForApi, {
configFile: false,
appType: "custom",
optimizeDeps: optimizeDepsNoRolldown,
environments: { client: { optimizeDeps: { rolldownOptions: _rolldownOptions } } }
});
async function buildCustomRoutes(subFolder, routes) {
const input = routes.reduce((entries, { page, file }) => {
entries[page.slice(1) + ".js"] = join(routerRoot, file);
return entries;
}, {});
const outputFormat = oneOptions?.build?.api?.outputFormat ?? serverOutputFormat;
const treeshake = oneOptions?.build?.api?.treeshake;
const mergedConfig = mergeConfig(apiBuildConfig, {
appType: "custom",
configFile: false,
define: vxrnOutput.processEnvDefines,
ssr: isUnified ? { optimizeDeps: optimizeDepsNoRolldown } : {
noExternal: true,
external: ["react", "react-dom"],
optimizeDeps: optimizeDepsNoRolldown
},
environments: { ssr: { optimizeDeps: { rolldownOptions: _rolldownOptions } } },
build: {
ssr: true,
emptyOutDir: false,
outDir: `${outDir}/${subFolder}`,
copyPublicDir: false,
minify: false,
rolldownOptions: {
treeshake: treeshake ?? { moduleSideEffects: false },
plugins: [outputFormat === "esm" ? rollupRemoveUnusedImportsPlugin : null].filter(Boolean),
preserveEntrySignatures: "strict",
input,
...isUnified ? {} : { external: [] },
output: {
entryFileNames: "[name]",
exports: "auto",
...outputFormat === "esm" ? {
format: "esm",
esModule: true
} : {
format: "cjs",
entryFileNames: (chunkInfo) => {
const name = chunkInfo.name.replace(/\.js$/, ".cjs");
return name;
},
chunkFileNames: (chunkInfo) => {
const chunkName = normalizePath(chunkInfo.name);
const dir = posix.dirname(chunkName);
const name = posix.basename(chunkName, posix.extname(chunkName));
return posix.join(dir, `${name}-[hash].cjs`);
},
assetFileNames: (assetInfo) => {
const assetName = normalizePath(assetInfo.name ?? "");
const dir = posix.dirname(assetName);
const baseName = posix.basename(assetName, posix.extname(assetName));
const ext = posix.extname(assetName);
return posix.join(dir, `${baseName}-[hash]${ext}`);
}
}
}
}
}
});
const userApiBuildConf = oneOptions.build?.api?.config;
const finalApiBuildConf = userApiBuildConf ? mergeConfig(mergedConfig, userApiBuildConf) : mergedConfig;
const output = await build$1(finalApiBuildConf);
return output;
}
const builtMiddlewares = {};
const apiPromise = manifest.apiRoutes.length ? (console.info(`
\u{1F528} build api routes
`), buildCustomRoutes("api", manifest.apiRoutes)) : Promise.resolve(null);
const middlewarePromise = manifest.middlewareRoutes.length ? (console.info(`
\u{1F528} build middlewares
`), buildCustomRoutes("middlewares", manifest.middlewareRoutes)) : Promise.resolve(null);
const [apiOutput, middlewareBuildInfo] = await Promise.all([apiPromise, middlewarePromise]);
if (middlewareBuildInfo) {
for (const middleware of manifest.middlewareRoutes) {
const absoluteRoot = resolve(process.cwd(), options.root);
const fullPath = normalizePath(join(absoluteRoot, routerRoot, middleware.file));
const outChunks = middlewareBuildInfo.output.filter((x) => x.type === "chunk");
const chunk = outChunks.find((x) => x.facadeModuleId === fullPath);
if (!chunk) throw new Error(`internal err finding middleware`);
builtMiddlewares[middleware.file] = posix.join(outDir, "middlewares", chunk.fileName);
}
}
globalThis["require"] = createRequire(import.meta.dirname + "/");
const assets = [];
const builtRoutes = [];
const sitemapData = [];
const collectImportsCache = /* @__PURE__ */ new Map();
const collectImportsInFlight = /* @__PURE__ */ new Set();
const cssFileContentsCache = /* @__PURE__ */ new Map();
const criticalCSSOutputPaths = getCriticalCSSOutputPaths(vxrnOutput.clientManifest);
const limit = pLimit(buildConcurrency);
const useWorkers = shouldUseWorkers(oneOptions);
const workerPool = useWorkers ? getWorkerPool(buildConcurrency) : null;
if (workerPool) {
const serializableOptions = JSON.parse(JSON.stringify(oneOptions, (_key, value) => typeof value === "function" ? void 0 : value));
await workerPool.initialize(serializableOptions);
}
const staticStartTime = performance.now();
const modeLabel = useWorkers ? `workers: ${workerPool?.size}` : `concurrency: ${buildConcurrency}`;
console.info(`
\u{1F528} build static routes (${modeLabel})
`);
const staticDir = join(`${outDir}/static`);
const clientDir = join(`${outDir}/client`);
await ensureDir(staticDir);
if (!vxrnOutput.serverOutput) {
throw new Error(`No server output`);
}
const clientChunksBySource = /* @__PURE__ */ new Map();
if (vxrnOutput.clientOutput) {
for (const chunk of vxrnOutput.clientOutput) {
if (chunk.type !== "chunk") continue;
const info = {
fileName: chunk.fileName,
imports: chunk.imports || []
};
for (const moduleId of chunk.moduleIds ?? []) {
clientChunksBySource.set(moduleId, info);
}
}
for (const chunk of vxrnOutput.clientOutput) {
if (chunk.type !== "chunk" || !chunk.facadeModuleId) continue;
clientChunksBySource.set(chunk.facadeModuleId, {
fileName: chunk.fileName,
imports: chunk.imports || []
});
}
}
const clientManifestByFile = /* @__PURE__ */ new Map();
for (const entry of Object.values(vxrnOutput.clientManifest)) {
if (entry.file) {
clientManifestByFile.set(entry.file, entry);
}
}
const outputEntries = [...vxrnOutput.serverOutput.entries()];
const layoutServerPaths = /* @__PURE__ */ new Map();
for (const [, output] of outputEntries) {
if (output.type === "asset") continue;
const id = output.facadeModuleId || "";
const file = Path.basename(id);
if (file.startsWith("_layout") && id.includes(`/${routerRoot}/`)) {
const relativePath = normalizePath(relative(process.cwd(), id)).replace(`${routerRoot}/`, "");
const contextKey = `./${relativePath}`;
layoutServerPaths.set(contextKey, output.fileName);
}
}
const routeByPath = /* @__PURE__ */ new Map();
for (const route of manifest.pageRoutes) {
if (route.file) {
const routePath = `${routerRoot}${route.file.slice(1)}`;
routeByPath.set(routePath, route);
}
}
for (const [, output] of outputEntries) {
if (output.type === "asset") {
assets.push(output);
}
}
const moduleIdToServerChunk = /* @__PURE__ */ new Map();
for (const [, output] of outputEntries) {
if (output.type === "asset") continue;
const moduleIds = output.moduleIds || (output.facadeModuleId ? [output.facadeModuleId] : []);
for (const moduleId of moduleIds) {
moduleIdToServerChunk.set(moduleId, output.fileName);
if (moduleId.includes("?one-spa-build")) {
moduleIdToServerChunk.set(moduleId.slice(0, moduleId.indexOf("?")), output.fileName);
}
}
}
for (const foundRoute of manifest.pageRoutes) {
let collectImports = function(entry, { type = "js" } = {}) {
const { imports = [], css } = entry;
const cacheKey = `${entry.file || imports.join(",")}:${type}`;
const cached = collectImportsCache.get(cacheKey);
if (cached) return cached;
if (collectImportsInFlight.has(cacheKey)) return [];
collectImportsInFlight.add(cacheKey);
const result = [...new Set([...type === "js" ? imports : css || [], ...imports.flatMap((name) => {
const found = vxrnOutput.clientManifest[name];
if (!found) {
console.warn(`No found imports`, name, vxrnOutput.clientManifest);
}
return collectImports(found, { type });
})].flat().filter((x) => x && (type === "css" || x.endsWith(".js"))).map((x) => type === "css" ? x : x.startsWith("assets/") ? x : `assets/${x.slice(1)}`))];
collectImportsInFlight.delete(cacheKey);
collectImportsCache.set(cacheKey, result);
return result;
};
if (!foundRoute.file) {
continue;
}
const routeModulePath = normalizePath(join(resolve(process.cwd(), options.root), routerRoot, foundRoute.file.slice(2)));
const serverFileName = moduleIdToServerChunk.get(routeModulePath);
if (!serverFileName) {
if (foundRoute.type === "spa") {
throw new Error(`[one] No build-only server chunk for SPA route: ${foundRoute.file}`);
}
console.warn(`[one] No server chunk found for route: ${foundRoute.file}`);
continue;
}
const onlyBuild = vxrnOutput.buildArgs?.only;
if (onlyBuild) {
const relativeId2 = foundRoute.file.slice(1);
if (!MicroMatch.contains(relativeId2, onlyBuild)) {
continue;
}
}
const clientChunk = clientChunksBySource.get(routeModulePath);
const manifestKey = `${routerRoot}${foundRoute.file.slice(1)}`;
const clientManifestEntry = vxrnOutput.clientManifest[manifestKey] ?? (clientChunk ? clientManifestByFile.get(clientChunk.fileName) : void 0);
if (!clientChunk && foundRoute.type !== "spa" && foundRoute.type !== "ssg") {
console.warn(`No client chunk found for route: ${routeModulePath}`);
continue;
}
foundRoute.loaderServerPath = serverFileName;
const relativeId = foundRoute.file.replace(/^\.\//, "/");
if (foundRoute.layouts) {
for (const layout of foundRoute.layouts) {
const serverPath = layoutServerPaths.get(layout.contextKey);
if (serverPath) {
layout.loaderServerPath = serverPath;
}
}
}
const entryImports = collectImports(clientManifestEntry || {});
const layoutEntries = foundRoute.layouts?.flatMap((layout) => {
const clientKey = `${routerRoot}${layout.contextKey.slice(1)}`;
const found = vxrnOutput.clientManifest[clientKey];
return found ? found : [];
}) ?? [];
const layoutImports = layoutEntries.flatMap((entry) => {
return [entry.file, ...collectImports(entry)];
});
const routePreloads = {};
const rootLayoutKey = `${routerRoot}/_layout.tsx`;
const rootLayoutEntry = vxrnOutput.clientManifest[rootLayoutKey];
if (rootLayoutEntry) {
routePreloads[`/${rootLayoutKey}`] = `/${rootLayoutEntry.file}`;
}
if (foundRoute.layouts) {
for (const layout of foundRoute.layouts) {
const clientKey = `${routerRoot}${layout.contextKey.slice(1)}`;
const entry = vxrnOutput.clientManifest[clientKey];
if (entry) {
routePreloads[`/${clientKey}`] = `/${entry.file}`;
}
}
}
const routeChunkFile = clientChunk?.fileName ?? clientManifestEntry?.file;
if (routeChunkFile) {
routePreloads[`/${routerRoot}${foundRoute.file.slice(1)}`] = `/${routeChunkFile}`;
}
const preloadSetupFilePreloads = (() => {
if (!oneOptions.setupFile) return [];
const clientSetupFile = typeof oneOptions.setupFile === "string" ? oneOptions.setupFile : oneOptions.setupFile.client;
if (!clientSetupFile) return [];
const needle = clientSetupFile.replace(/^\.\//, "");
for (const file in vxrnOutput.clientManifest) {
if (file === needle) {
const entry = vxrnOutput.clientManifest[file];
return [entry.file];
}
}
return [];
})();
const allPreloads = [.../* @__PURE__ */ new Set([
...preloadSetupFilePreloads,
...clientChunk ? [clientChunk.fileName] : clientManifestEntry ? [clientManifestEntry.file] : [],
vxrnOutput.clientManifest["virtual:one-entry"].file,
...entryImports,
...layoutImports
])].map((path) => `/${path}`);
const scriptLoadingMode = oneOptions.web?.experimental_scriptLoading;
const useDeferredLoading = scriptLoadingMode === "defer-non-critical";
const useAggressiveLCP = scriptLoadingMode === "after-lcp-aggressive";
const needsSeparatedPreloads = useDeferredLoading || useAggressiveLCP;
const criticalPreloads = needsSeparatedPreloads ? [.../* @__PURE__ */ new Set([
...preloadSetupFilePreloads,
vxrnOutput.clientManifest["virtual:one-entry"].file,
...clientChunk ? [clientChunk.fileName] : clientManifestEntry ? [clientManifestEntry.file] : [],
...layoutEntries.map((entry) => entry.file)
])].map((path) => `/${path}`) : void 0;
const deferredPreloads = needsSeparatedPreloads ? [.../* @__PURE__ */ new Set([...entryImports, ...layoutEntries.flatMap((entry) => collectImports(entry))])].filter((path) => !criticalPreloads.includes(`/${path}`)).map((path) => `/${path}`) : void 0;
const preloads2 = needsSeparatedPreloads ? [...criticalPreloads, ...deferredPreloads] : allPreloads;
const allEntries = [clientManifestEntry, ...layoutEntries].filter(Boolean);
const layoutCSS = [...new Set(layoutEntries.flatMap((entry) => collectImports(entry, { type: "css" })).map((path) => `/${path}`))];
const allCSS = [.../* @__PURE__ */ new Set([
...layoutCSS,
...clientManifestEntry ? collectImports(clientManifestEntry, { type: "css" }).map((path) => `/${path}`) : [],
...Object.entries(vxrnOutput.clientManifest).filter(([key, entry]) => {
if (!key.endsWith(".css")) return false;
const src = entry.src;
return src === "style.css";
}).map(([, entry]) => `/${entry.file}`)
])];
const hasCriticalCSS = allCSS.some((p) => criticalCSSOutputPaths.has(p));
const needsCSSContents = oneOptions.web?.inlineLayoutCSS || hasCriticalCSS;
let allCSSContents;
if (needsCSSContents) {
allCSSContents = await Promise.all(allCSS.map(async (cssPath) => {
if (!oneOptions.web?.inlineLayoutCSS && !criticalCSSOutputPaths.has(cssPath)) {
return "";
}
const cached = cssFileContentsCache.get(cssPath);
if (cached !== void 0) return cached;
const filePath = join(clientDir, cssPath);
try {
const content = await FSExtra.readFile(filePath, "utf-8");
cssFileContentsCache.set(cssPath, content);
return content;
} catch (err) {
console.warn(`[one] Warning: Could not read CSS file ${filePath}`);
cssFileContentsCache.set(cssPath, "");
return "";
}
}));
}
if (process.env.DEBUG) {
console.info("[one] building routes", {
foundRoute,
layoutEntries,
allEntries,
allCSS
});
}
const serverJsPath = posix.join(outDir, "server", serverFileName);
let exported;
try {
exported = await getRouteExports(vxrnOutput.serverEntry, routerRoot, foundRoute.file);
} catch (err) {
console.error(`Error importing page (original error)`, err);
throw new Error(`Error importing page: ${foundRoute.file}`, { cause: err });
}
foundRoute.hasLoader = typeof exported.loader === "function";
const isDynamic = !!Object.keys(foundRoute.routeKeys).length;
if (foundRoute.type === "ssg" && isDynamic && !foundRoute.page.includes("+not-found") && !foundRoute.page.includes("_sitemap") && !exported.generateStaticParams) {
throw new Error(`[one] Error: Missing generateStaticParams
Route ${foundRoute.page} of type ${foundRoute.type} must export generateStaticParams so build can complete.
See docs on generateStaticParams:
https://onestack.dev/docs/routing-exports#generatestaticparams
`);
}
const paramsList = await exported.generateStaticParams?.() ?? [{}];
console.info(`
[build] page ${relativeId} (with ${paramsList.length} routes)
`);
if (process.env.DEBUG) {
console.info(`paramsList`, JSON.stringify(paramsList, null, 2));
}
const routeSitemapExport = exported.sitemap;
const isAfterLCPMode = scriptLoadingMode === "after-lcp" || scriptLoadingMode === "after-lcp-aggressive";
const useAfterLCP = foundRoute.type === "ssg" && isAfterLCPMode;
const useAfterLCPAggressive = foundRoute.type === "ssg" && scriptLoadingMode === "after-lcp-aggressive";
const shouldCollectSitemap = foundRoute.type !== "api" && foundRoute.type !== "layout" && !foundRoute.isNotFound && !foundRoute.page.includes("+not-found") && !foundRoute.page.includes("_sitemap");
const pageBuilds = paramsList.map((params) => {
const path = getPathnameFromFilePath(relativeId, params, foundRoute.type === "ssg");
if (workerPool) {
console.info(` \u21A6 route ${path}`);
return workerPool.buildPage({
serverEntry: vxrnOutput.serverEntry,
routerRoot,
path,
relativeId,
params,
foundRoute,
clientManifestEntry,
staticDir,
clientDir,
builtMiddlewares,
serverJsPath,
preloads: preloads2,
allCSS,
layoutCSS,
routePreloads,
allCSSContents,
criticalPreloads,
deferredPreloads,
useAfterLCP,
useAfterLCPAggressive
}).then((built) => ({
built,
path
}));
}
return limit(async () => {
console.info(` \u21A6 route ${path}`);
const built = await runWithAsyncLocalContext(async () => {
return await buildPage(vxrnOutput.serverEntry, routerRoot, path, relativeId, params, foundRoute, clientManifestEntry, staticDir, clientDir, builtMiddlewares, serverJsPath, preloads2, allCSS, layoutCSS, routePreloads, allCSSContents, criticalPreloads, deferredPreloads, useAfterLCP, useAfterLCPAggressive);
});
return {
built,
path
};
});
});
const results = await Promise.all(pageBuilds);
for (const { built, path } of results) {
builtRoutes.push(built);
if (shouldCollectSitemap) {
sitemapData.push({
path,
routeExport: routeSitemapExport
});
}
}
}
if (workerPool) {
await terminateWorkerPool();
}
const staticTime = performance.now() - staticStartTime;
console.info(`
\u23F1\uFE0F static routes: ${(staticTime / 1e3).toFixed(2)}s (${builtRoutes.length} pages)
`);
printBuildTimings();
await moveAllFiles(staticDir, clientDir);
await FSExtra.remove(staticDir);
const routeMap = {};
const routeToBuildInfo = {};
const pathToRoute = {};
const preloads = {};
const cssPreloads = {};
const loaders = {};
let cssContentsByPath;
for (const route of builtRoutes) {
if (!route.cleanPath.includes("*")) {
routeMap[route.cleanPath] = route.htmlPath;
}
const { loaderData: _loaderData, cssContents, ...rest } = route;
if (cssContents) {
const contentsByPath = cssContentsByPath ||= {};
route.css.forEach((cssPath, index) => {
const content = cssContents[index];
if (content) contentsByPath[cssPath] = content;
});
}
routeToBuildInfo[route.routeFile] = rest;
for (const p of getCleanPaths([route.path, route.cleanPath])) {
pathToRoute[p] = route.routeFile;
}
preloads[route.preloadPath] = true;
cssPreloads[route.cssPreloadPath] = true;
loaders[route.loaderPath] = true;
}
function createBuildManifestRoute(route) {
const { layouts, ...built } = route;
if (layouts?.length) {
;
built.layouts = layouts.map((layout) => ({
contextKey: layout.contextKey,
loaderServerPath: layout.loaderServerPath
}));
}
const buildInfo = builtRoutes.find((x) => x.routeFile === route.file);
if (built.middlewares) {
for (const [index, mw] of built.middlewares.entries()) {
const viaBuildInfo = buildInfo?.middlewares?.[index];
if (viaBuildInfo) {
mw.contextKey = viaBuildInfo;
continue;
}
const viaMiddlewareMap = builtMiddlewares[mw.contextKey];
if (viaMiddlewareMap) {
mw.contextKey = viaMiddlewareMap;
}
}
}
if (buildInfo) {
built.loaderPath = buildInfo.loaderPath;
}
return built;
}
const buildInfoForWriting = {
outDir,
oneOptions,
routeToBuildInfo,
cssContentsByPath,
pathToRoute,
manifest: {
pageRoutes: manifest.pageRoutes.map(createBuildManifestRoute),
apiRoutes: manifest.apiRoutes.map(createBuildManifestRoute),
allRoutes: manifest.allRoutes.map(createBuildManifestRoute)
},
routeMap,
constants: JSON.parse(JSON.stringify({ ...constants })),
preloads,
cssPreloads,
loaders,
useRolldown: await isRolldown()
};
await writeJSON(toAbsolute(`${outDir}/buildInfo.json`), buildInfoForWriting);
await writeBuildOutputPointer(outDir);
await FSExtra.writeFile(join(clientDir, "version.json"), JSON.stringify({ version: constants.CACHE_KEY }));
console.info(`
\u{1F6E1} skew protection: emitted version.json
`);
const sitemapConfig = oneOptions.web?.sitemap;
if (sitemapConfig) {
const sitemapOptions = typeof sitemapConfig === "boolean" ? {} : sitemapConfig;
const sitemapXml = generateSitemap(sitemapData, sitemapOptions);
const sitemapPath = join(clientDir, "sitemap.xml");
await FSExtra.writeFile(sitemapPath, sitemapXml);
console.info(`
\u{1F4C4} generated sitemap.xml (${sitemapData.length} URLs)
`);
}
const postBuildLogs = [];
const platform = deployConfig?.target;
if (platform) {
postBuildLogs.push(`[one.build] platform ${platform}`);
}
switch (platform) {
case "vercel": {
const vercelJsonPath = join(options.root, "vercel.json");
if (FSExtra.existsSync(vercelJsonPath)) {
try {
const vercelConfig = JSON.parse(FSExtra.readFileSync(vercelJsonPath, "utf-8"));
if (!vercelConfig.cleanUrls) {
console.warn(`
\u26A0\uFE0F Warning: Your vercel.json is missing "cleanUrls": true`);
console.warn(` Without this, direct navigation to SSG pages will 404.`);
console.warn(` Add "cleanUrls": true to your vercel.json to fix this.
`);
}
} catch {}
}
await buildVercelOutputDirectory({
apiOutput,
buildInfoForWriting,
clientDir,
oneOptionsRoot: options.root,
postBuildLogs
});
break;
}
case "cloudflare": {
const workerSrcDir = join(options.root, outDir);
const getWorkerSourceImportPath = (routeFile) => {
const importPath = normalizePath(relative(workerSrcDir, join(options.root, routerRoot, routeFile)));
return importPath.startsWith(".") ? importPath : `./${importPath}`;
};
const apiRouteMap = [];
const middlewareRouteMap = [];
for (const route of buildInfoForWriting.manifest.apiRoutes) {
if (route.file) {
const importPath = getWorkerSourceImportPath(route.file);
apiRouteMap.push(` '${route.page}': () => import('${importPath}')`);
}
}
for (const [sourceFile, builtPath] of Object.entries(builtMiddlewares)) {
const importPath = getWorkerSourceImportPath(sourceFile);
middlewareRouteMap.push(` '${builtPath}': () => import('${importPath}')`);
}
const workerSrcPath = join(options.root, outDir, "_worker-src.js");
const workerCode = `// Polyfill MessageChannel for React SSR (not available in Cloudflare Workers by default)
if (typeof MessageChannel === 'undefined') {
globalThis.MessageChannel = class MessageChannel {
constructor() {
this.port1 = { postMessage: () => {}, onmessage: null, close: () => {} }
this.port2 = { postMessage: () => {}, onmessage: null, close: () => {} }
}
}
}
import { serve, setFetchStaticHtml, withRange } from 'one/serve-worker'
// Lazy import map - modules load on-demand when route is matched
const lazyRoutes = {
serverEntry: () => import('./server/_virtual_one-entry.js'),
api: {
${apiRouteMap.join(",\n")}
},
middlewares: {
${middlewareRouteMap.join(",\n")}
}
}
const buildInfo = ${JSON.stringify(buildInfoForWriting)}
let server
export default {
async fetch(request, env, ctx) {
if (!server) {
server = await serve(buildInfo, lazyRoutes)
}
// set up static HTML fetcher for this request (uses ASSETS binding)
if (env.ASSETS) {
setFetchStaticHtml(async (path) => {
try {
const url = new URL(request.url)
url.pathname = path
const assetResponse = await env.ASSETS.fetch(new Request(url))
if (assetResponse && assetResponse.ok) {
return await assetResponse.text()
}
} catch (e) {
// asset not found
}
return null
})
}
try {
const response = await server.fetch(request, env, ctx)
// no route matched or 404 \u2192 try static assets
if (!response || response.status === 404) {
if (env.ASSETS) {
try {
const assetResponse = await env.ASSETS.fetch(request)
if (assetResponse && assetResponse.status !== 404) {
return await withRange(request, assetResponse)
}
} catch (e) {
// asset not found, continue with original response
}
}
}
return response
} finally {
setFetchStaticHtml(null)
}
}
}
`;
await FSExtra.writeFile(workerSrcPath, workerCode);
const projectName = await getCloudflareProjectName(options.root);
const userWranglerConfig = await loadUserWranglerConfig(options.root);
const wranglerInputConfig = createCloudflareWranglerConfig(projectName, userWranglerConfig?.config);
wranglerInputConfig.main = normalizePath(relative(join(options.root, outDir), workerSrcPath));
const wranglerInputPath = join(options.root, outDir, "_wrangler.input.jsonc");
await FSExtra.writeFile(wranglerInputPath, `${JSON.stringify(wranglerInputConfig, null, 2)}
`);
const ssrExternal = viteLoadedConfig?.config?.ssr?.external;
const workerExternals = Array.isArray(ssrExternal) ? ssrExternal : [];
console.info("\n [cloudflare] Bundling worker...");
const { cloudflare } = await import("@cloudflare/vite-plugin");
const builder = await createBuilder({
root: options.root,
mode: "production",
logLevel: "warn",
configFile: false,
define: {
"process.env.NODE_ENV": JSON.stringify("production"),
"process.env.VITE_ENVIRONMENT": JSON.stringify("ssr"),
"process.env.ONE_CACHE_KEY": JSON.stringify(constants.CACHE_KEY)
},
plugins: [environmentGuardPlugin(oneOptions.environmentGuards), cloudflare({
configPath: wranglerInputPath,
viteEnvironment: { name: "worker" }
})],
resolve: {
alias: [
{
find: /^react-native\/Libraries\/.*/,
replacement: resolvePath("@vxrn/vite-plugin-metro/empty", options.root)
},
{
find: /^(react-native\/asset-registry|@react-native\/assets-registry\/registry)$/,
replacement: "react-native-web/dist/modules/AssetRegistry"
},
{
find: "react-native/package.json",
replacement: "react-native-web/package.json"
},
{
find: "react-native",
replacement: "react-native-web"
},
...Object.entries(absorbedPackageAliases(options.root, "web")).map(([find, replacement]) => ({
find,
replacement
}))
],
dedupe: ["react-native-web"]
},
build: {
outDir,
emptyOutDir: false,
rolldownOptions: {
external: workerExternals,
shimMissingExports: true,
output: { strictExecutionOrder: true }
}
}
});
const workerEnv = builder.environments.worker;
if (!workerEnv) {
throw new Error("[one] plugin did not register \"worker\" environment");
}
await builder.build(workerEnv);
await FSExtra.remove(workerSrcPath);
await FSExtra.remove(wranglerInputPath);
await finalizeCloudflareWranglerDeployConfig(join(options.root, outDir, "worker", "wrangler.json"));
if (userWranglerConfig) {
console.info(` [cloudflare] Merging ${relative(options.root, userWranglerConfig.path)} into ${outDir}/worker/wrangler.json`);
}
postBuildLogs.push(`Cloudflare worker bundled at ${outDir}/worker/index.js`);
postBuildLogs.push(`To deploy: wrangler deploy`);
break;
}
}
const securityScanOption = oneOptions.build?.securityScan;
const securityScanLevel = securityScanOption === false ? null : securityScanOption === true || securityScanOption === void 0 ? "warn" : typeof securityScanOption === "string" ? securityScanOption : securityScanOption.level ?? "warn";
const securitySafePatterns = typeof securityScanOption === "object" && securityScanOption !== null ? securityScanOption.safePatterns : void 0;
if (securityScanLevel) {
const { runSecurityScan } = await import("./securityScan.mjs");
const passed = await runSecurityScan(clientDir, securityScanLevel, securitySafePatterns);
if (!passed) {
process.exit(1);
}
}
if (postBuildLogs.length) {
console.info(`
`);
postBuildLogs.forEach((log) => {
console.info(` \xB7 ${log}`);
});
}
console.info(`
\u{1F49B} build complete
`);
}
const TRAILING_INDEX_REGEX = /\/index(\.(web))?/;
function getCleanPaths(possiblePaths) {
return Array.from(new Set(Array.from(new Set(possiblePaths)).flatMap((p) => {
const paths = [p];
if (p.match(TRAILING_INDEX_REGEX)) {
const pathWithTrailingIndexRemoved = p.replace(TRAILING_INDEX_REGEX, "");
paths.push(pathWithTrailingIndexRemoved);
paths.push(pathWithTrailingIndexRemoved + "/");
}
return paths;
})));
}
async function moveAllFiles(src, dest) {
try {
await FSExtra.copy(src, dest, {
overwrite: true,
errorOnExist: false
});
} catch (err) {
console.error("Error moving files:", err);
}
}
export { build };
//# sourceMappingURL=build.mjs.map