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

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

"use strict";

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
	for (var name in all) __defProp(target, name, {
		get: all[name],
		enumerable: true
	});
};
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") {
		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: () => from[key],
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
	value: mod,
	enumerable: true
}) : target, mod));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var buildVercelOutputDirectory_exports = {};
__export(buildVercelOutputDirectory_exports, { buildVercelOutputDirectory: () => buildVercelOutputDirectory });
module.exports = __toCommonJS(buildVercelOutputDirectory_exports);
var import_path = require("path");
var import_fs_extra = __toESM(require("fs-extra"), 1);
var import_ts_pattern = require("ts-pattern");
var import_vc_build_output_config_base = require("./config/vc-build-output-config-base.native.js");
var import_vc_package_base = require("./config/vc-package-base.native.js");
var import_createApiServerlessFunction = require("./generate/createApiServerlessFunction.native.js");
var import_createSsrServerlessFunction = require("./generate/createSsrServerlessFunction.native.js");
var import_getPathFromRoute = require("./getPathFromRoute.native.js");
var { copy, ensureDir, existsSync, remove, writeJSON } = import_fs_extra.default;
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 = (0, import_path.resolve)((0, import_path.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 (0, import_ts_pattern.isMatching)({
				code: import_ts_pattern.P.string,
				facadeModuleId: import_ts_pattern.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 (0, import_createApiServerlessFunction.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 = (0, import_path.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 (0, import_createSsrServerlessFunction.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 = (0, import_path.resolve)((0, import_path.join)(oneOptionsRoot, outDir, "middlewares"));
	if (existsSync(distMiddlewareDir)) {
		var vercelMiddlewareDir = (0, import_path.resolve)((0, import_path.join)(oneOptionsRoot, ".vercel/output/functions/_middleware.func"));
		await ensureDir(vercelMiddlewareDir);
		postBuildLogs.push(`[one.build][vercel] copying middlewares from ${distMiddlewareDir} to ${vercelMiddlewareDir}`);
		await moveAllFiles((0, import_path.resolve)((0, import_path.join)(oneOptionsRoot, outDir, "middlewares")), vercelMiddlewareDir);
		var vercelMiddlewarePackageJsonFilePath = (0, import_path.resolve)((0, import_path.join)(vercelMiddlewareDir, "package.json"));
		postBuildLogs.push(`[one.build][vercel] writing package.json to ${vercelMiddlewarePackageJsonFilePath}`);
		await writeJSON(vercelMiddlewarePackageJsonFilePath, import_vc_package_base.serverlessVercelPackageJson);
		var wrappedMiddlewareEntryPointFilename = "_wrapped_middleware.js";
		var wrappedMiddlewareEntryPointPath = (0, import_path.resolve)((0, import_path.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 import_fs_extra.default.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 = (0, import_path.resolve)((0, import_path.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 = (0, import_path.resolve)((0, import_path.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 = (0, import_getPathFromRoute.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 = (0, import_path.resolve)((0, import_path.join)(oneOptionsRoot, ".vercel/output", "config.json"));
	await writeJSON(vercelConfigFilePath, {
		...import_vc_build_output_config_base.vercelBuildOutputConfigBase,
		routes: [
			...import_vc_build_output_config_base.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: `${(0, import_getPathFromRoute.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}`);
};

//# sourceMappingURL=buildVercelOutputDirectory.native.js.map