@modern-js/server-core
Version:
A Progressive React Framework for modern web development.
216 lines (215 loc) • 8.68 kB
JavaScript
import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
import { _ as _ts_values } from "@swc/helpers/_/_ts_values";
import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
import { getLoaderCtx } from "../../helper";
import { sortRoutes } from "../../utils";
import { CustomServer } from "../customServer";
import { requestLatencyMiddleware } from "../monitors";
export * from "./inject";
var renderPlugin = function() {
return {
name: "@modern-js/plugin-render",
setup: function setup(api) {
return {
prepare: function prepare() {
return _async_to_generator(function() {
var _api_useAppContext, middlewares, routes, render, pwd, renderMiddlewares, hooks, config, customServer, pageRoutes, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err;
return _ts_generator(this, function(_state) {
switch (_state.label) {
case 0:
_api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, routes = _api_useAppContext.routes, render = _api_useAppContext.render, pwd = _api_useAppContext.distDirectory, renderMiddlewares = _api_useAppContext.renderMiddlewares;
hooks = api.getHooks();
config = api.useConfigContext();
if (!routes) {
return [
2
];
}
customServer = new CustomServer(hooks, pwd);
pageRoutes = getPageRoutes(routes);
middlewares.push({
name: "page-latency",
handler: requestLatencyMiddleware()
});
_iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
_state.label = 1;
case 1:
_state.trys.push([
1,
6,
7,
8
]);
_loop = function() {
var route, _config_server, originUrlPath, _route_entryName, entryName, urlPath, customServerHookMiddleware, customServerMiddleware;
return _ts_generator(this, function(_state2) {
switch (_state2.label) {
case 0:
route = _step.value;
originUrlPath = route.urlPath, _route_entryName = route.entryName, entryName = _route_entryName === void 0 ? MAIN_ENTRY_NAME : _route_entryName;
urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
if (((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.disableHook) !== true) {
customServerHookMiddleware = customServer.getHookMiddleware(entryName, routes);
middlewares.push({
name: "custom-server-hook",
path: urlPath,
handler: customServerHookMiddleware
});
}
renderMiddlewares === null || renderMiddlewares === void 0 ? void 0 : renderMiddlewares.forEach(function(m) {
middlewares.push({
name: m.name,
path: urlPath,
handler: m.handler
});
});
return [
4,
customServer.getServerMiddleware()
];
case 1:
customServerMiddleware = _state2.sent();
customServerMiddleware && middlewares.push({
name: "custom-server-middleware",
path: urlPath,
handler: customServerMiddleware
});
render && middlewares.push({
name: "render",
path: urlPath,
handler: createRenderHandler(render)
});
return [
2
];
}
});
};
_iterator = pageRoutes[Symbol.iterator]();
_state.label = 2;
case 2:
if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
return [
3,
5
];
return [
5,
_ts_values(_loop())
];
case 3:
_state.sent();
_state.label = 4;
case 4:
_iteratorNormalCompletion = true;
return [
3,
2
];
case 5:
return [
3,
8
];
case 6:
err = _state.sent();
_didIteratorError = true;
_iteratorError = err;
return [
3,
8
];
case 7:
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
return [
7
];
case 8:
return [
2
];
}
});
})();
}
};
}
};
};
function getPageRoutes(routes) {
return routes.filter(function(route) {
return !route.isApi;
}).sort(sortRoutes);
}
function createRenderHandler(render) {
return function() {
var _ref = _async_to_generator(function(c, _) {
var _c_env_node, logger, reporter, monitors, templates, serverManifest, rscServerManifest, rscClientManifest, rscSSRManifest, locals, metrics, matchPathname, matchEntryName, loaderContext, request, nodeReq, res, body, status, headers, headersData;
return _ts_generator(this, function(_state) {
switch (_state.label) {
case 0:
logger = c.get("logger");
reporter = c.get("reporter");
monitors = c.get("monitors");
templates = c.get("templates") || {};
serverManifest = c.get("serverManifest") || {};
rscServerManifest = c.get("rscServerManifest");
rscClientManifest = c.get("rscClientManifest");
rscSSRManifest = c.get("rscSSRManifest");
locals = c.get("locals");
metrics = c.get("metrics");
matchPathname = c.get("matchPathname");
matchEntryName = c.get("matchEntryName");
loaderContext = getLoaderCtx(c);
request = c.req.raw;
nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
return [
4,
render(request, {
nodeReq,
monitors,
logger,
reporter,
templates,
metrics,
serverManifest,
rscServerManifest,
rscClientManifest,
rscSSRManifest,
loaderContext,
locals,
matchPathname,
matchEntryName
})
];
case 1:
res = _state.sent();
body = res.body, status = res.status, headers = res.headers;
headersData = {};
headers.forEach(function(v, k) {
headersData[k] = v;
});
return [
2,
c.body(body, status, headersData)
];
}
});
});
return function(c, _) {
return _ref.apply(this, arguments);
};
}();
}
export {
renderPlugin
};