one
Version:
One is a new React Framework that makes Vite serve both native and web.
215 lines (207 loc) • 11.1 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: !0 });
}, __copyProps = (to, from, except, desc) => {
if (from && typeof from == "object" || typeof from == "function")
for (let key of __getOwnPropNames(from))
!__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(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
mod
)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
var buildVercelOutputDirectory_exports = {};
__export(buildVercelOutputDirectory_exports, {
buildVercelOutputDirectory: () => buildVercelOutputDirectory
});
module.exports = __toCommonJS(buildVercelOutputDirectory_exports);
var import_node_path = require("node:path"), import_fs_extra = __toESM(require("fs-extra"), 1), import_ts_pattern = require("ts-pattern"), import_createApiServerlessFunction = require("./generate/createApiServerlessFunction"), import_createSsrServerlessFunction = require("./generate/createSsrServerlessFunction"), import_vc_package_base = require("./config/vc-package-base"), import_vc_build_output_config_base = require("./config/vc-build-output-config-base"), import_getPathFromRoute = require("./getPathFromRoute"), { copy, ensureDir, existsSync, writeJSON } = import_fs_extra.default;
async function moveAllFiles(src, dest) {
try {
await copy(src, dest, {
overwrite: !0,
errorOnExist: !1
});
} catch (err) {
console.error("Error moving files:", err);
}
}
function getMiddlewaresByNamedRegex(buildInfoForWriting) {
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("dist/middlewares/") ? m.contextKey.substring(17) : 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, { routeToBuildInfo } = buildInfoForWriting;
if (apiOutput) {
var _apiOutput_output, compiltedApiRoutes = ((_apiOutput_output = apiOutput == null ? void 0 : apiOutput.output) !== null && _apiOutput_output !== void 0 ? _apiOutput_output : []).filter(function(o) {
return (0, import_ts_pattern.isMatching)({
code: import_ts_pattern.P.string,
facadeModuleId: import_ts_pattern.P.string
}, o);
}), _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
try {
for (var _loop = async function() {
var route2 = _step.value, compiledRoute = compiltedApiRoutes.find(function(compiled) {
var flag = compiled.facadeModuleId.includes(route2.file.replace("./", ""));
return flag;
});
compiledRoute ? (postBuildLogs.push(`[one.build][vercel] generating serverless function for apiRoute ${route2.page}`), await (0, import_createApiServerlessFunction.createApiServerlessFunction)(route2, compiledRoute.code, oneOptionsRoot, postBuildLogs)) : console.warn(`
\u{1F528}[one.build][vercel] apiRoute missing code compilation for`, route2.file);
}, _iterator = buildInfoForWriting.manifest.apiRoutes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) await _loop();
} catch (err) {
_didIteratorError = !0, _iteratorError = err;
} finally {
try {
!_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
} finally {
if (_didIteratorError)
throw _iteratorError;
}
}
}
var vercelOutputFunctionsDir = (0, import_node_path.join)(oneOptionsRoot, ".vercel/output/functions");
await ensureDir(vercelOutputFunctionsDir);
var _iteratorNormalCompletion1 = !0, _didIteratorError1 = !1, _iteratorError1 = void 0;
try {
for (var _iterator1 = buildInfoForWriting.manifest.pageRoutes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
var route = _step1.value;
switch (route.type) {
case "ssr": {
var builtPageRoute = routeToBuildInfo[route.file];
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 = !0, _iteratorError1 = err;
} finally {
try {
!_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
} finally {
if (_didIteratorError1)
throw _iteratorError1;
}
}
var distMiddlewareDir = (0, import_node_path.resolve)((0, import_node_path.join)(oneOptionsRoot, "dist", "middlewares"));
if (existsSync(distMiddlewareDir)) {
var vercelMiddlewareDir = (0, import_node_path.resolve)((0, import_node_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_node_path.resolve)((0, import_node_path.join)(oneOptionsRoot, "dist", "middlewares")), vercelMiddlewareDir);
var vercelMiddlewarePackageJsonFilePath = (0, import_node_path.resolve)((0, import_node_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", wrappedMiddlewareEntryPointPath = (0, import_node_path.resolve)((0, import_node_path.join)(vercelMiddlewareDir, wrappedMiddlewareEntryPointFilename)), middlewaresByNamedRegex = getMiddlewaresByNamedRegex(buildInfoForWriting), middlewaresToVariableNameMap = middlewaresByNamedRegex.reduce(function(acc, param2) {
var [namedRegex, middlewares] = param2;
return (Array.isArray(middlewares) ? middlewares : [
middlewares
]).forEach(function(middleware) {
var middlewareVariableName = middleware.replace(/\.[a-z]+$/, "").replaceAll("/", "_");
acc[middleware] = middlewareVariableName;
}), 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(`
`)}
function getMiddleware(path) {
switch (path){
${Object.entries(middlewaresToVariableNameMap).map(function(param2) {
var [path, variableName] = param2;
return `case '${path}': return ${variableName}`;
}).join(`
`)}
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_node_path.resolve)((0, import_node_path.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 = (0, import_node_path.resolve)((0, import_node_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 vercelConfigFilePath = (0, import_node_path.resolve)((0, import_node_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: !0
}
] : [],
{
handle: "rewrite"
},
...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}`);
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
buildVercelOutputDirectory
});
//# sourceMappingURL=buildVercelOutputDirectory.js.map