one
Version:
One is a new React Framework that makes Vite serve both native and web.
277 lines (269 loc) • 10.9 kB
JavaScript
import { join, resolve } from "path";
import FSExtra from "fs-extra";
import { isMatching, P } 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 (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 \u{1F528}[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",
// Seems that middlewares only work with edge runtime
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 loaderPattern = cleanPath.replace(/:([^_]+)/g, "(?<$1>[^_]+)");
var src = `^/assets/${loaderPattern}(?:_refetch_\\d+)?_\\d+_vxrn_loader\\.js$`;
var dest = `${pagePath}?__loader=1`;
var paramMatches = cleanPath.match(/:([^_]+)/g);
if (paramMatches) {
var _iteratorNormalCompletion2 = true,
_didIteratorError2 = false,
_iteratorError2 = void 0;
try {
for (var _iterator2 = paramMatches[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var match = _step2.value;
var paramName = match.slice(1);
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 vercelConfigFilePath = resolve(join(oneOptionsRoot, ".vercel/output", "config.json"));
await writeJSON(vercelConfigFilePath, {
...vercelBuildOutputConfigBase,
routes: [...vercelBuildOutputConfigBase.routes, ...(existsSync(distMiddlewareDir) ? [{
src: "/(.*)",
middlewarePath: "_middleware",
continue: true
}] : []), {
handle: "rewrite"
},
// SSR loader routes must come before dynamic page routes
...ssrLoaderRoutes, ...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