one/dist/esm/vercel/build/buildVercelOutputDirectory.native.js

One is a React framework for web, iOS, and Android apps.

import { join, resolve } from "path";
import FSExtra from "fs-extra";
import { P, isMatching } from "ts-pattern";
import { vercelBuildOutputConfigBase } from "./config/vc-build-output-config-base.native.js";
import { serverlessVercelPackageJson } from "./config/vc-package-base.native.js";
import { createApiServerlessFunction } from "./generate/createApiServerlessFunction.native.js";
import { createSsrServerlessFunction } from "./generate/createSsrServerlessFunction.native.js";
import { getPathFromRoute } from "./getPathFromRoute.native.js";

var { copy, ensureDir, existsSync, remove, writeJSON } = FSExtra;
async function moveAllFiles(src, dest) {
	try {
		await copy(src, dest, {
			overwrite: true,
			errorOnExist: false
		});
	} catch (err) {
		console.error("Error moving files:", err);
	}
}
function getMiddlewaresByNamedRegex(buildInfoForWriting) {
	var outDir = buildInfoForWriting.outDir || "dist";
	var prefix = `${outDir}/middlewares/`;
	return buildInfoForWriting.manifest.allRoutes.filter(function(r) {
		return r.middlewares && r.middlewares.length > 0;
	}).map(function(r) {
		return [r.namedRegex, r.middlewares.map(function(m) {
			return m.contextKey.startsWith(prefix) ? m.contextKey.substring(prefix.length) : m.contextKey;
		})];
	}).sort(function(a, b) {
		return b[0].length - a[0].length;
	});
}
var buildVercelOutputDirectory = async function buildVercelOutputDirectory2(param) {
	var { apiOutput, buildInfoForWriting, clientDir, oneOptionsRoot, postBuildLogs } = param;
	var outDir = buildInfoForWriting.outDir || "dist";
	var vercelOutputDir = resolve(join(oneOptionsRoot, ".vercel/output"));
	if (existsSync(vercelOutputDir)) {
		await remove(vercelOutputDir);
	}
	var { routeToBuildInfo } = buildInfoForWriting;
	if (apiOutput) {
		var _ref;
		var compiltedApiRoutes = ((_ref = apiOutput === null || apiOutput === void 0 ? void 0 : apiOutput.output) !== null && _ref !== void 0 ? _ref : []).filter(function(o) {
			return isMatching({
				code: P.string,
				facadeModuleId: P.string
			}, o);
		});
		var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
		try {
			var _loop = async function() {
				var route2 = _step.value;
				var compiledRoute = compiltedApiRoutes.find(function(compiled) {
					var flag = compiled.facadeModuleId.includes(route2.file.replace("./", ""));
					return flag;
				});
				if (compiledRoute) {
					postBuildLogs.push(`[one.build][vercel] generating serverless function for apiRoute ${route2.page}`);
					await createApiServerlessFunction(route2, compiledRoute.code, oneOptionsRoot, postBuildLogs, outDir);
				} else {
					console.warn("\n 🔨[one.build][vercel] apiRoute missing code compilation for", route2.file);
				}
			};
			for (var _iterator = buildInfoForWriting.manifest.apiRoutes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) await _loop();
		} catch (err) {
			_didIteratorError = true;
			_iteratorError = err;
		} finally {
			try {
				if (!_iteratorNormalCompletion && _iterator.return != null) {
					_iterator.return();
				}
			} finally {
				if (_didIteratorError) {
					throw _iteratorError;
				}
			}
		}
	}
	var vercelOutputFunctionsDir = join(oneOptionsRoot, ".vercel/output/functions");
	await ensureDir(vercelOutputFunctionsDir);
	var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
	try {
		for (var _iterator1 = buildInfoForWriting.manifest.pageRoutes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
			var route = _step1.value;
			switch (route.type) {
				case "ssr": {
					var builtPageRoute = routeToBuildInfo[route.file];
					if (builtPageRoute) {
						postBuildLogs.push(`[one.build][vercel] generate serverless function for ${route.page} with ${route.type}`);
						await createSsrServerlessFunction(route, buildInfoForWriting, oneOptionsRoot, postBuildLogs);
					}
					break;
				}
				default: break;
			}
		}
	} catch (err) {
		_didIteratorError1 = true;
		_iteratorError1 = err;
	} finally {
		try {
			if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
				_iterator1.return();
			}
		} finally {
			if (_didIteratorError1) {
				throw _iteratorError1;
			}
		}
	}
	var distMiddlewareDir = resolve(join(oneOptionsRoot, outDir, "middlewares"));
	if (existsSync(distMiddlewareDir)) {
		var vercelMiddlewareDir = resolve(join(oneOptionsRoot, ".vercel/output/functions/_middleware.func"));
		await ensureDir(vercelMiddlewareDir);
		postBuildLogs.push(`[one.build][vercel] copying middlewares from ${distMiddlewareDir} to ${vercelMiddlewareDir}`);
		await moveAllFiles(resolve(join(oneOptionsRoot, outDir, "middlewares")), vercelMiddlewareDir);
		var vercelMiddlewarePackageJsonFilePath = resolve(join(vercelMiddlewareDir, "package.json"));
		postBuildLogs.push(`[one.build][vercel] writing package.json to ${vercelMiddlewarePackageJsonFilePath}`);
		await writeJSON(vercelMiddlewarePackageJsonFilePath, serverlessVercelPackageJson);
		var wrappedMiddlewareEntryPointFilename = "_wrapped_middleware.js";
		var wrappedMiddlewareEntryPointPath = resolve(join(vercelMiddlewareDir, wrappedMiddlewareEntryPointFilename));
		var middlewaresByNamedRegex = getMiddlewaresByNamedRegex(buildInfoForWriting);
		var middlewaresToVariableNameMap = middlewaresByNamedRegex.reduce(function(acc, param2) {
			var [namedRegex, middlewares] = param2;
			;
			(Array.isArray(middlewares) ? middlewares : [middlewares]).forEach(function(middleware) {
				var middlewareVariableName = middleware.replace(/\.[a-z]+$/, "").replaceAll("/", "_");
				acc[middleware] = middlewareVariableName;
			});
			return acc;
		}, {});
		await FSExtra.writeFile(wrappedMiddlewareEntryPointPath, `
const middlewaresByNamedRegex = ${JSON.stringify(middlewaresByNamedRegex)}
${Object.entries(middlewaresToVariableNameMap).map(function(param2) {
			var [path, variableName] = param2;
			return `import ${variableName} from './${path}'`;
		}).join("\n")}

function getMiddleware(path) {
  switch (path){
      ${Object.entries(middlewaresToVariableNameMap).map(function(param2) {
			var [path, variableName] = param2;
			return `case '${path}': return ${variableName}`;
		}).join("\n")}
      default: return null
  }
}

const next = (e) => {
  const t = new Headers(null == e ? void 0 : e.headers)
  t.set('x-middleware-next', '1')
  return new Response(null, { ...e, headers: t })
}

const wrappedMiddlewareFunction = (request, event) => {
  const url = new URL(request.url)
  const pathname = url.pathname
  
  // Find matching middlewares for this request
  const matchingMiddlewares = [...middlewaresByNamedRegex
    .filter(([namedRegex]) => new RegExp(namedRegex).test(pathname))
    .reduce((prev, current) => prev.length > current[1]?.length ? prev : current[1], [])];
  
  // Import and execute the middleware function
  const boundNext = () => {
    if (matchingMiddlewares.length === 0) {
      return next(request)
    }
      
    const middleware = getMiddleware(matchingMiddlewares.shift())
    return middleware ? middleware({request, event, next: boundNext}) : next(request)
  };
  return boundNext()
}

export { wrappedMiddlewareFunction as default }
  `);
		var middlewareVercelConfigFilePath = resolve(join(vercelMiddlewareDir, ".vc-config.json"));
		postBuildLogs.push(`[one.build][vercel] writing .vc-config.json to ${middlewareVercelConfigFilePath}`);
		await writeJSON(middlewareVercelConfigFilePath, {
			runtime: "edge",
			entrypoint: wrappedMiddlewareEntryPointFilename
		});
	}
	var vercelOutputStaticDir = resolve(join(oneOptionsRoot, ".vercel/output/static"));
	await ensureDir(vercelOutputStaticDir);
	postBuildLogs.push(`[one.build][vercel] copying static files from ${clientDir} to ${vercelOutputStaticDir}`);
	await moveAllFiles(clientDir, vercelOutputStaticDir);
	var ssrLoaderRoutes = buildInfoForWriting.manifest.pageRoutes.filter(function(r) {
		return r.type === "ssr";
	}).map(function(r) {
		var pagePath = getPathFromRoute(r) || "/";
		var cleanPath = pagePath.slice(1).replace(/\//g, "_");
		var paramPattern = /\[(?:\.\.\.)?(\w+)\]/g;
		var loaderPattern = cleanPath.replace(paramPattern, "(?<$1>[^_]+)");
		var src = `^/assets/${loaderPattern}(?:_refetch_\\d+)?_\\d+_vxrn_loader\\.js$`;
		var dest = `${pagePath}?__loader=1`;
		var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
		try {
			for (var _iterator2 = cleanPath.matchAll(paramPattern)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
				var [, paramName] = _step2.value;
				dest += `&${paramName}=$${paramName}`;
			}
		} catch (err) {
			_didIteratorError2 = true;
			_iteratorError2 = err;
		} finally {
			try {
				if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
					_iterator2.return();
				}
			} finally {
				if (_didIteratorError2) {
					throw _iteratorError2;
				}
			}
		}
		return {
			src,
			dest
		};
	});
	var spaRoutes = buildInfoForWriting.manifest.pageRoutes.filter(function(route2) {
		return route2.type === "spa" && !route2.isNotFound;
	}).flatMap(function(route2) {
		var _routeToBuildInfo_route_file;
		var htmlPath = (_routeToBuildInfo_route_file = routeToBuildInfo[route2.file]) === null || _routeToBuildInfo_route_file === void 0 ? void 0 : _routeToBuildInfo_route_file.htmlPath;
		return htmlPath ? [{
			src: route2.namedRegex,
			dest: htmlPath
		}] : [];
	});
	var vercelConfigFilePath = resolve(join(oneOptionsRoot, ".vercel/output", "config.json"));
	await writeJSON(vercelConfigFilePath, {
		...vercelBuildOutputConfigBase,
		routes: [
			...vercelBuildOutputConfigBase.routes,
			...existsSync(distMiddlewareDir) ? [{
				src: "/(.*)",
				middlewarePath: "_middleware",
				continue: true
			}] : [],
			{ handle: "rewrite" },
			...ssrLoaderRoutes,
			...spaRoutes,
			...buildInfoForWriting.manifest.allRoutes.filter(function(r) {
				return r.routeKeys && Object.keys(r.routeKeys).length > 0;
			}).map(function(r) {
				return {
					src: r.namedRegex,
					dest: `${getPathFromRoute(r) || "/"}?${Object.entries(r.routeKeys).map(function(param2) {
						var [k, v] = param2;
						return `${k}=$${v}`;
					}).join("&")}`
				};
			})
		]
	});
	postBuildLogs.push(`[one.build] wrote vercel config to: ${vercelConfigFilePath}`);
};

export { buildVercelOutputDirectory };
//# sourceMappingURL=buildVercelOutputDirectory.native.js.map