@modern-js/server-core 2.53.0 → 2.54.0

package/dist/esm/{base/adapters/node/middlewares/serverManifest.js → adapters/node/plugins/resource.js}

@@ -2,7 +2,114 @@ import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
 import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, fs } from "@modern-js/utils";
+function getHtmlTemplates(pwd, routes) {
+  return _getHtmlTemplates.apply(this, arguments);
+}
+function _getHtmlTemplates() {
+  _getHtmlTemplates = _async_to_generator(function(pwd, routes) {
+    var htmls, templates;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            Promise.all(routes.map(function() {
+              var _ref = _async_to_generator(function(route) {
+                var html, _this, htmlPath, e;
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      _state2.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                      ]);
+                      htmlPath = path.join(pwd, route.entryPath);
+                      return [
+                        4,
+                        fileReader.readFile(htmlPath, "utf-8")
+                      ];
+                    case 1:
+                      html = (_this = _state2.sent()) === null || _this === void 0 ? void 0 : _this.toString();
+                      return [
+                        3,
+                        3
+                      ];
+                    case 2:
+                      e = _state2.sent();
+                      return [
+                        3,
+                        3
+                      ];
+                    case 3:
+                      return [
+                        2,
+                        [
+                          route.entryName,
+                          html
+                        ]
+                      ];
+                  }
+                });
+              });
+              return function(route) {
+                return _ref.apply(this, arguments);
+              };
+            }()) || [])
+          ];
+        case 1:
+          htmls = _state.sent();
+          templates = Object.fromEntries(htmls);
+          return [
+            2,
+            templates
+          ];
+      }
+    });
+  });
+  return _getHtmlTemplates.apply(this, arguments);
+}
+function injectTemplates(pwd, routes) {
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var templates;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            if (!(routes && !c.get("templates")))
+              return [
+                3,
+                2
+              ];
+            return [
+              4,
+              getHtmlTemplates(pwd, routes)
+            ];
+          case 1:
+            templates = _state.sent();
+            c.set("templates", templates);
+            _state.label = 2;
+          case 2:
+            return [
+              4,
+              next()
+            ];
+          case 3:
+            _state.sent();
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
 var dynamicImport = function(filePath) {
   try {
     var module = require(filePath);
@@ -163,7 +270,38 @@ function injectServerManifest(pwd, routes) {
     };
   }();
 }
+var injectResourcePlugin = function() {
+  return {
+    name: "@modern-js/plugin-inject-resource",
+    setup: function setup(api) {
+      return {
+        prepare: function prepare() {
+          return _async_to_generator(function() {
+            var _api_useAppContext, middlewares, routes, pwd;
+            return _ts_generator(this, function(_state) {
+              _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, routes = _api_useAppContext.routes, pwd = _api_useAppContext.distDirectory;
+              middlewares.push({
+                name: "inject-server-manifest",
+                handler: injectServerManifest(pwd, routes)
+              });
+              middlewares.push({
+                name: "inject-html",
+                handler: injectTemplates(pwd, routes)
+              });
+              return [
+                2
+              ];
+            });
+          })();
+        }
+      };
+    }
+  };
+};
 export {
+  getHtmlTemplates,
   getServerManifest,
-  injectServerManifest
+  injectResourcePlugin,
+  injectServerManifest,
+  injectTemplates
 };

package/dist/esm/{base/adapters/node/middlewares/serverStatic.js → adapters/node/plugins/static.js}

@@ -1,11 +1,115 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { fs } from "@modern-js/utils";
 import { getMimeType } from "hono/utils/mime";
 import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { createPublicMiddleware } from "./serverPublic";
+import { sortRoutes } from "../../../utils";
+var serverStaticPlugin = function() {
+  return {
+    name: "@modern-js/plugin-server-static",
+    setup: function setup(api) {
+      return {
+        prepare: function prepare() {
+          var _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, pwd = _api_useAppContext.distDirectory, routes = _api_useAppContext.routes;
+          var config = api.useConfigContext();
+          var serverStaticMiddleware = createStaticMiddleware({
+            pwd,
+            routes,
+            output: config.output || {},
+            html: config.html || {}
+          });
+          middlewares.push({
+            name: "server-static",
+            handler: serverStaticMiddleware
+          });
+        }
+      };
+    }
+  };
+};
+function createPublicMiddleware(param) {
+  var pwd = param.pwd, routes = param.routes;
+  return function() {
+    var _ref = _async_to_generator(function(c, next) {
+      var route, entryPath, filename, data, mimeType;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            route = matchRoute(c.req, routes);
+            if (!route)
+              return [
+                3,
+                2
+              ];
+            entryPath = route.entryPath;
+            filename = path.join(pwd, entryPath);
+            return [
+              4,
+              fileReader.readFile(filename, "buffer")
+            ];
+          case 1:
+            data = _state.sent();
+            mimeType = getMimeType(filename);
+            if (data !== null) {
+              if (mimeType) {
+                c.header("Content-Type", mimeType);
+              }
+              Object.entries(route.responseHeaders || {}).forEach(function(param2) {
+                var _param = _sliced_to_array(param2, 2), k = _param[0], v = _param[1];
+                c.header(k, v);
+              });
+              return [
+                2,
+                c.body(data, 200)
+              ];
+            }
+            _state.label = 2;
+          case 2:
+            return [
+              4,
+              next()
+            ];
+          case 3:
+            return [
+              2,
+              _state.sent()
+            ];
+        }
+      });
+    });
+    return function(c, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+function matchRoute(req, routes) {
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = routes.sort(sortRoutes)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var route = _step.value;
+      if (!route.isSSR && route.entryPath.startsWith("public") && req.path.startsWith(route.urlPath)) {
+        return route;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return void 0;
+}
 function createStaticMiddleware(options) {
   var pwd = options.pwd, routes = options.routes;
   var prefix = options.output.assetPrefix || "/";
@@ -114,5 +218,7 @@ var prepareFavicons = function(favicon, faviconByEntries) {
   return faviconNames;
 };
 export {
-  createStaticMiddleware
+  createPublicMiddleware,
+  createStaticMiddleware,
+  serverStaticPlugin
 };

package/dist/esm/{base/constants.js → constants.js}

@@ -23,9 +23,11 @@ var ServerReportTimings;
   ServerReportTimings2["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
 })(ServerReportTimings || (ServerReportTimings = {}));
 var X_RENDER_CACHE = "x-render-cache";
+var X_MODERNJS_RENDER = "x-modernjs-render";
 export {
   AGGRED_DIR,
   REPLACE_REG,
   ServerReportTimings,
+  X_MODERNJS_RENDER,
   X_RENDER_CACHE
 };

package/dist/esm/index.js

@@ -1,5 +1,17 @@
-export * from "./core/plugin";
-export * from "./core/render";
+import { createErrorHtml, onError, ErrorDigest } from "./utils";
+import { AGGRED_DIR } from "./constants";
+import { createServerBase } from "./serverBase";
+import { PluginManager } from "./pluginManager";
+export * from "./plugins";
+export * from "./types/plugin";
+export * from "./types/render";
 export * from "@modern-js/plugin";
-export * from "./core/loadPlugins";
 export * from "./types/config";
+export {
+  AGGRED_DIR,
+  ErrorDigest,
+  PluginManager,
+  createErrorHtml,
+  createServerBase,
+  onError
+};

package/dist/esm/pluginManager.js

@@ -0,0 +1,140 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _class_private_field_get } from "@swc/helpers/_/_class_private_field_get";
+import { _ as _class_private_field_init } from "@swc/helpers/_/_class_private_field_init";
+import { _ as _class_private_field_set } from "@swc/helpers/_/_class_private_field_set";
+import { _ as _class_private_method_get } from "@swc/helpers/_/_class_private_method_get";
+import { _ as _class_private_method_init } from "@swc/helpers/_/_class_private_method_init";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { createAsyncManager, createAsyncPipeline, createAsyncWaterfall, createContext, createParallelWorkflow } from "@modern-js/plugin";
+import { loadConfig } from "./utils";
+var _appContext = /* @__PURE__ */ new WeakMap(), _plugins = /* @__PURE__ */ new WeakMap(), _options = /* @__PURE__ */ new WeakMap(), _configContext = /* @__PURE__ */ new WeakMap(), _createCoreManager = /* @__PURE__ */ new WeakSet(), _initConfigContext = /* @__PURE__ */ new WeakSet();
+var PluginManager = /* @__PURE__ */ function() {
+  "use strict";
+  function PluginManager2(options) {
+    _class_call_check(this, PluginManager2);
+    _class_private_method_init(this, _createCoreManager);
+    _class_private_method_init(this, _initConfigContext);
+    _class_private_field_init(this, _appContext, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_init(this, _plugins, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_init(this, _options, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_init(this, _configContext, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_set(this, _plugins, []);
+    _class_private_field_set(this, _configContext, createContext({}));
+    _class_private_field_set(this, _appContext, options.appContext);
+    _class_private_field_set(this, _configContext, createContext(options.serverConfig || {}));
+    _class_private_field_set(this, _options, options);
+  }
+  var _proto = PluginManager2.prototype;
+  _proto.init = function init() {
+    var _this = this;
+    return _async_to_generator(function() {
+      var coreManager, runner;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            coreManager = _class_private_method_get(_this, _createCoreManager, createCoreManager).call(_this);
+            return [
+              4,
+              coreManager.init()
+            ];
+          case 1:
+            runner = _state.sent();
+            return [
+              4,
+              _class_private_method_get(_this, _initConfigContext, initConfigContext).call(_this, runner)
+            ];
+          case 2:
+            _state.sent();
+            return [
+              2,
+              runner
+            ];
+        }
+      });
+    })();
+  };
+  _proto.addPlugins = function addPlugins(plugins) {
+    var _$_class_private_field_get;
+    (_$_class_private_field_get = _class_private_field_get(this, _plugins)).push.apply(_$_class_private_field_get, _to_consumable_array(plugins));
+  };
+  return PluginManager2;
+}();
+function createCoreManager() {
+  var _this = this;
+  var _class_private_field_get_serverConfig;
+  var hooks = {
+    config: createAsyncWaterfall(),
+    prepare: createAsyncWaterfall(),
+    reset: createParallelWorkflow(),
+    prepareWebServer: createAsyncPipeline(),
+    fallback: createParallelWorkflow(),
+    prepareApiServer: createAsyncPipeline(),
+    afterMatch: createAsyncPipeline(),
+    afterRender: createAsyncPipeline(),
+    afterStreamingRender: createAsyncPipeline()
+  };
+  var pluginApi = {
+    useConfigContext: function() {
+      return _class_private_field_get(_this, _configContext).use().value;
+    },
+    useAppContext: function() {
+      return _class_private_field_get(_this, _appContext).use().value;
+    },
+    setAppContext: function(c) {
+      return _class_private_field_get(_this, _appContext).set(c);
+    }
+  };
+  var coreManager = createAsyncManager(hooks, pluginApi);
+  this.addPlugins(((_class_private_field_get_serverConfig = _class_private_field_get(this, _options).serverConfig) === null || _class_private_field_get_serverConfig === void 0 ? void 0 : _class_private_field_get_serverConfig.plugins) || []);
+  _class_private_field_get(this, _plugins).forEach(function(p) {
+    var plugin = coreManager.createPlugin(p.setup, p);
+    coreManager.usePlugin(plugin);
+  });
+  return coreManager;
+}
+function initConfigContext(runner) {
+  return _initConfigContext1.apply(this, arguments);
+}
+function _initConfigContext1() {
+  _initConfigContext1 = _async_to_generator(function(runner) {
+    var _$_class_private_field_get, serverConfig, cliConfig, mergedConfig, finalServerConfig;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          _$_class_private_field_get = _class_private_field_get(this, _options), serverConfig = _$_class_private_field_get.serverConfig, cliConfig = _$_class_private_field_get.cliConfig;
+          mergedConfig = loadConfig({
+            cliConfig,
+            serverConfig: serverConfig || {}
+          });
+          return [
+            4,
+            runner.config(mergedConfig)
+          ];
+        case 1:
+          finalServerConfig = _state.sent();
+          _class_private_field_get(this, _configContext).set(finalServerConfig);
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _initConfigContext1.apply(this, arguments);
+}
+export {
+  PluginManager
+};

package/dist/esm/{base/middlewares → plugins}/customServer/index.js

@@ -180,7 +180,7 @@ var CustomServer = /* @__PURE__ */ function() {
             if (Array.isArray(serverMiddleware)) {
               return [
                 2,
-                getUnstableMiddlewares(serverMiddleware)
+                getServerMidFromUnstableMid(serverMiddleware)
               ];
             }
             return [
@@ -242,15 +242,7 @@ var CustomServer = /* @__PURE__ */ function() {
   };
   return CustomServer2;
 }();
-function isRedirect(headers, code) {
-  return [
-    301,
-    302,
-    307,
-    308
-  ].includes(code || 0) || headers.get("Location");
-}
-function getUnstableMiddlewares(serverMiddleware) {
+function getServerMidFromUnstableMid(serverMiddleware) {
   return serverMiddleware.map(function(middleware) {
     return function() {
       var _ref = _async_to_generator(function(c, next) {
@@ -269,6 +261,14 @@ function getUnstableMiddlewares(serverMiddleware) {
     }();
   });
 }
+function isRedirect(headers, code) {
+  return [
+    301,
+    302,
+    307,
+    308
+  ].includes(code || 0) || headers.get("Location");
+}
 function createMiddlewareContextFromHono(c) {
   var loaderContext = getLoaderCtx(c);
   return {
@@ -296,5 +296,6 @@ function createMiddlewareContextFromHono(c) {
 }
 export {
   CustomServer,
-  getLoaderCtx2 as getLoaderCtx
+  getLoaderCtx2 as getLoaderCtx,
+  getServerMidFromUnstableMid
 };

package/dist/esm/plugins/favicon.js

@@ -0,0 +1,34 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+var faviconPlugin = function() {
+  return {
+    name: "@modern-js/plugin-favicon",
+    setup: function setup(api) {
+      return {
+        prepare: function prepare() {
+          var middlewares = api.useAppContext().middlewares;
+          middlewares.push({
+            name: "favicon-fallback",
+            path: "/favicon.ico",
+            handler: function() {
+              var _ref = _async_to_generator(function(c, _next) {
+                return _ts_generator(this, function(_state) {
+                  return [
+                    2,
+                    c.body(null, 204)
+                  ];
+                });
+              });
+              return function(c, _next) {
+                return _ref.apply(this, arguments);
+              };
+            }()
+          });
+        }
+      };
+    }
+  };
+};
+export {
+  faviconPlugin
+};

package/dist/esm/plugins/index.js

@@ -0,0 +1,15 @@
+import { renderPlugin, getRenderHandler } from "./render";
+import { faviconPlugin } from "./favicon";
+import { processedByPlugin } from "./processedBy";
+import { getLoaderCtx } from "./customServer";
+import { logPlugin } from "./log";
+import { monitorPlugin } from "./monitor";
+export {
+  faviconPlugin,
+  getLoaderCtx,
+  getRenderHandler,
+  logPlugin,
+  monitorPlugin,
+  processedByPlugin,
+  renderPlugin
+};

package/dist/esm/{base/middlewares/logger.js → plugins/log.js}

@@ -47,6 +47,21 @@ function logHandler() {
           case 0:
             method = c.req.method;
             _$logger = c.get("logger");
+            if (!!_$logger)
+              return [
+                3,
+                2
+              ];
+            return [
+              4,
+              next()
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+          case 2:
             path = getPathname(c.req.raw);
             logFn = _$logger.debug;
             log(logFn, "<--", method, path);
@@ -55,7 +70,7 @@ function logHandler() {
               4,
               next()
             ];
-          case 1:
+          case 3:
             _state.sent();
             log(logFn, "-->", method, path, c.res.status, time(start));
             return [
@@ -70,6 +85,22 @@ function logHandler() {
     return logger;
   }();
 }
+var logPlugin = function() {
+  return {
+    name: "@modern-js/plugin-log",
+    setup: function setup(api) {
+      return {
+        prepare: function prepare() {
+          var middlewares = api.useAppContext().middlewares;
+          middlewares.push({
+            name: "print_log",
+            handler: logHandler()
+          });
+        }
+      };
+    }
+  };
+};
 export {
-  logHandler
+  logPlugin
 };