npm - @modern-js/prod-server - Versions diffs - 2.4.1-beta.0 → 2.5.1-alpha.0 - Mend

@modern-js/prod-server 2.4.1-beta.0 → 2.5.1-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (125) hide show

package/CHANGELOG.md +18 -3
package/dist/cjs/constants.js +62 -0
package/dist/cjs/index.js +44 -0
package/dist/cjs/libs/context/context.js +189 -0
package/dist/cjs/libs/context/index.js +30 -0
package/dist/cjs/libs/hook-api/index.js +151 -0
package/dist/cjs/libs/hook-api/route.js +43 -0
package/dist/cjs/libs/hook-api/template.js +97 -0
package/dist/cjs/libs/loadConfig.js +76 -0
package/dist/cjs/libs/logger.js +122 -0
package/dist/cjs/libs/metrics.js +34 -0
package/dist/cjs/libs/proxy.js +81 -0
package/dist/cjs/libs/render/cache/__tests__/cache.fun.test.js +93 -0
package/dist/cjs/libs/render/cache/__tests__/cache.test.js +210 -0
package/dist/cjs/libs/render/cache/__tests__/cacheable.js +70 -0
package/dist/cjs/libs/render/cache/__tests__/error-configuration.js +60 -0
package/dist/cjs/libs/render/cache/__tests__/matched-cache.js +114 -0
package/dist/cjs/libs/render/cache/index.js +97 -0
package/dist/cjs/libs/render/cache/page-caches/index.js +33 -0
package/dist/cjs/libs/render/cache/page-caches/lru.js +58 -0
package/dist/cjs/libs/render/cache/spr.js +242 -0
package/dist/cjs/libs/render/cache/type.js +15 -0
package/dist/cjs/libs/render/cache/util.js +116 -0
package/dist/cjs/libs/render/index.js +93 -0
package/dist/cjs/libs/render/measure.js +75 -0
package/dist/cjs/libs/render/reader.js +118 -0
package/dist/cjs/libs/render/ssr.js +103 -0
package/dist/cjs/libs/render/static.js +67 -0
package/dist/cjs/libs/render/type.js +32 -0
package/dist/cjs/libs/route/index.js +78 -0
package/dist/cjs/libs/route/matcher.js +106 -0
package/dist/cjs/libs/route/route.js +39 -0
package/dist/cjs/libs/serve-file.js +77 -0
package/dist/cjs/server/index.js +169 -0
package/dist/cjs/server/modern-server-split.js +66 -0
package/dist/cjs/server/modern-server.js +491 -0
package/dist/cjs/type.js +15 -0
package/dist/cjs/utils.js +152 -0
package/dist/cjs/worker-server.js +93 -0
package/dist/esm/constants.js +29 -0
package/dist/esm/index.js +13 -0
package/dist/esm/libs/context/context.js +274 -0
package/dist/esm/libs/context/index.js +5 -0
package/dist/esm/libs/hook-api/index.js +281 -0
package/dist/esm/libs/hook-api/route.js +68 -0
package/dist/esm/libs/hook-api/template.js +127 -0
package/dist/esm/libs/loadConfig.js +82 -0
package/dist/esm/libs/logger.js +205 -0
package/dist/esm/libs/metrics.js +6 -0
package/dist/esm/libs/proxy.js +244 -0
package/dist/esm/libs/render/cache/__tests__/cache.fun.test.js +291 -0
package/dist/esm/libs/render/cache/__tests__/cache.test.js +781 -0
package/dist/esm/libs/render/cache/__tests__/cacheable.js +67 -0
package/dist/esm/libs/render/cache/__tests__/error-configuration.js +45 -0
package/dist/esm/libs/render/cache/__tests__/matched-cache.js +147 -0
package/dist/esm/libs/render/cache/index.js +346 -0
package/dist/esm/libs/render/cache/page-caches/index.js +154 -0
package/dist/esm/libs/render/cache/page-caches/lru.js +84 -0
package/dist/esm/libs/render/cache/spr.js +492 -0
package/dist/esm/libs/render/cache/type.js +1 -0
package/dist/esm/libs/render/cache/util.js +280 -0
package/dist/esm/libs/render/index.js +234 -0
package/dist/esm/libs/render/measure.js +146 -0
package/dist/esm/libs/render/reader.js +339 -0
package/dist/esm/libs/render/ssr.js +223 -0
package/dist/esm/libs/render/static.js +216 -0
package/dist/esm/libs/render/type.js +7 -0
package/dist/esm/libs/route/index.js +130 -0
package/dist/esm/libs/route/matcher.js +143 -0
package/dist/esm/libs/route/route.js +40 -0
package/dist/esm/libs/serve-file.js +184 -0
package/dist/esm/server/index.js +505 -0
package/dist/esm/server/modern-server-split.js +360 -0
package/dist/esm/server/modern-server.js +1090 -0
package/dist/esm/type.js +1 -0
package/dist/esm/utils.js +147 -0
package/dist/esm/worker-server.js +233 -0
package/dist/esm-node/constants.js +35 -0
package/dist/esm-node/index.js +18 -0
package/dist/esm-node/libs/context/context.js +160 -0
package/dist/esm-node/libs/context/index.js +6 -0
package/dist/esm-node/libs/hook-api/index.js +119 -0
package/dist/esm-node/libs/hook-api/route.js +20 -0
package/dist/esm-node/libs/hook-api/template.js +73 -0
package/dist/esm-node/libs/loadConfig.js +45 -0
package/dist/esm-node/libs/logger.js +98 -0
package/dist/esm-node/libs/metrics.js +11 -0
package/dist/esm-node/libs/proxy.js +57 -0
package/dist/esm-node/libs/render/cache/__tests__/cache.fun.test.js +83 -0
package/dist/esm-node/libs/render/cache/__tests__/cache.test.js +210 -0
package/dist/esm-node/libs/render/cache/__tests__/cacheable.js +47 -0
package/dist/esm-node/libs/render/cache/__tests__/error-configuration.js +37 -0
package/dist/esm-node/libs/render/cache/__tests__/matched-cache.js +91 -0
package/dist/esm-node/libs/render/cache/index.js +76 -0
package/dist/esm-node/libs/render/cache/page-caches/index.js +10 -0
package/dist/esm-node/libs/render/cache/page-caches/lru.js +29 -0
package/dist/esm-node/libs/render/cache/spr.js +220 -0
package/dist/esm-node/libs/render/cache/type.js +0 -0
package/dist/esm-node/libs/render/cache/util.js +80 -0
package/dist/esm-node/libs/render/index.js +64 -0
package/dist/esm-node/libs/render/measure.js +51 -0
package/dist/esm-node/libs/render/reader.js +85 -0
package/dist/esm-node/libs/render/ssr.js +80 -0
package/dist/esm-node/libs/render/static.js +38 -0
package/dist/esm-node/libs/render/type.js +9 -0
package/dist/esm-node/libs/route/index.js +54 -0
package/dist/esm-node/libs/route/matcher.js +87 -0
package/dist/esm-node/libs/route/route.js +16 -0
package/dist/esm-node/libs/serve-file.js +47 -0
package/dist/esm-node/server/index.js +156 -0
package/dist/esm-node/server/modern-server-split.js +43 -0
package/dist/esm-node/server/modern-server.js +484 -0
package/dist/esm-node/type.js +0 -0
package/dist/esm-node/utils.js +120 -0
package/dist/esm-node/worker-server.js +69 -0
package/dist/js/modern/libs/render/index.js +4 -2
package/dist/js/modern/server/modern-server.js +14 -8
package/dist/js/node/libs/render/index.js +4 -2
package/dist/js/node/server/modern-server.js +14 -8
package/dist/js/treeshaking/libs/render/index.js +4 -3
package/dist/js/treeshaking/server/modern-server.js +14 -8
package/dist/types/libs/context/context.d.ts +1 -1
package/dist/types/libs/render/index.d.ts +3 -1
package/dist/types/utils.d.ts +1 -1
package/package.json +17 -18

package/dist/esm/type.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ "use strict";

package/dist/esm/utils.js ADDED Viewed

@@ -0,0 +1,147 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import { createDebugger, isProd } from "@modern-js/utils";
+var debug = createDebugger("prod-server");
+var mergeExtension = function(users) {
+    var output = [];
+    return {
+        middleware: output.concat(users)
+    };
+};
+var noop = function() {};
+var createErrorDocument = function(status, text) {
+    var title = "".concat(status, ": ").concat(text);
+    return '<!DOCTYPE html>\n  <html lang="en">\n  <head>\n    <meta charset="utf-8">\n    <meta name="viewport" content="width=device-width">\n    <title>'.concat(title, '</title>\n    <style>\n      html,body {\n        margin: 0;\n      }\n\n      .page-container {\n        color: #000;\n        background: #fff;\n        height: 100vh;\n        text-align: center;\n        display: flex;\n        flex-direction: column;\n        align-items: center;\n        justify-content: center;\n      }\n    </style>\n  </head>\n  <body>\n    <div class="page-container">\n    <h1>').concat(status, "</h1>\n    <div>").concat(text, "</div>\n  </body>\n  </html>\n  ");
+};
+var createMiddlewareCollecter = function() {
+    var webMiddlewares = [];
+    var apiMiddlewares = [];
+    var addWebMiddleware = function(input) {
+        webMiddlewares.push(input);
+    };
+    var addAPIMiddleware = function(input) {
+        apiMiddlewares.push(input);
+    };
+    var getMiddlewares = function() {
+        return {
+            web: webMiddlewares,
+            api: apiMiddlewares
+        };
+    };
+    return {
+        getMiddlewares: getMiddlewares,
+        addWebMiddleware: addWebMiddleware,
+        addAPIMiddleware: addAPIMiddleware
+    };
+};
+var useLocalPrefix = function(url) {
+    return isProd() && !url.includes(".");
+};
+var getStaticReg = function() {
+    var output = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, html = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var tmp = output.distPath, _ref = tmp === void 0 ? {} : tmp, cssPath = _ref.css, jsPath = _ref.js, mediaPath = _ref.media, _output_assetPrefix = output.assetPrefix, assetPrefix = _output_assetPrefix === void 0 ? "/" : _output_assetPrefix;
+    var favicon = html.favicon, faviconByEntries = html.faviconByEntries;
+    var prefix = useLocalPrefix(assetPrefix) ? assetPrefix : "";
+    var favicons = prepareFavicons(favicon, faviconByEntries);
+    var staticFiles = [
+        cssPath,
+        jsPath,
+        mediaPath
+    ].filter(function(v) {
+        return Boolean(v);
+    });
+    var staticReg = [
+        "static/",
+        "upload/"
+    ].concat(_toConsumableArray(staticFiles));
+    var iconReg = [
+        "favicon.ico",
+        "icon.png"
+    ].concat(_toConsumableArray(favicons));
+    var regPrefix = prefix.endsWith("/") ? prefix : "".concat(prefix, "/");
+    var staticPathRegExp = new RegExp("^".concat(regPrefix, "(").concat(_toConsumableArray(staticReg).concat(_toConsumableArray(iconReg)).join("|"), ")"));
+    return staticPathRegExp;
+};
+var prepareFavicons = function(favicon, faviconByEntries) {
+    var faviconNames = [];
+    if (favicon) {
+        faviconNames.push(favicon.substring(favicon.lastIndexOf("/") + 1));
+    }
+    if (faviconByEntries) {
+        Object.keys(faviconByEntries).forEach(function(f) {
+            var curFavicon = faviconByEntries[f];
+            if (curFavicon) {
+                faviconNames.push(curFavicon.substring(curFavicon.lastIndexOf("/") + 1));
+            }
+        });
+    }
+    return faviconNames;
+};
+var headersWithoutCookie = function(headers) {
+    if (typeof headers.cookie !== "undefined") {
+        var safeHeaders = _objectSpread({}, headers);
+        delete safeHeaders.cookie;
+        return safeHeaders;
+    }
+    return headers;
+};
+var isRedirect = function(code) {
+    return [
+        301,
+        302,
+        307,
+        308
+    ].includes(code);
+};
+export { createErrorDocument, createMiddlewareCollecter, debug, getStaticReg, headersWithoutCookie, isRedirect, mergeExtension, noop, prepareFavicons, useLocalPrefix };

package/dist/esm/worker-server.js ADDED Viewed

@@ -0,0 +1,233 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return(g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g);
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+var _ctx_request, _ctx_request1, _ctx_request2;
+import { Logger } from "./libs/logger";
+import { RouteMatchManager } from "./libs/route";
+import { metrics as defaultMetrics } from "./libs/metrics";
+var handleUrl = function(url) {
+    return url.replace(/^https?:\/\/.*?\//gi, "/");
+};
+var createHandler = function(manifest) {
+    var routeMgr = new RouteMatchManager();
+    var pages = manifest.pages, routes = manifest.routes;
+    routeMgr.reset(routes);
+    return function() {
+        var _ref = _asyncToGenerator(function(ctx) {
+            var pageMatch, page, _query, _pathname, _params, params, e;
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        pageMatch = routeMgr.match(ctx.url);
+                        if (!pageMatch) {
+                            ctx.body = "404: Page not found";
+                            ctx.status = 404;
+                            return [
+                                2
+                            ];
+                        }
+                        page = pages[pageMatch.spec.urlPath];
+                        (_query = (_ctx_request = ctx.request).query) !== null && _query !== void 0 ? _query : _ctx_request.query = ctx.query;
+                        (_pathname = (_ctx_request1 = ctx.request).pathname) !== null && _pathname !== void 0 ? _pathname : _ctx_request1.pathname = ctx.pathname;
+                        (_params = (_ctx_request2 = ctx.request).params) !== null && _params !== void 0 ? _params : _ctx_request2.params = ctx.params;
+                        params = pageMatch.parseURLParams(ctx.url);
+                        if (!page.serverRender) return [
+                            3,
+                            4
+                        ];
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        return [
+                            4,
+                            page.serverRender({
+                                entryName: page.entryName,
+                                template: page.template,
+                                query: ctx.query,
+                                request: ctx.request,
+                                response: ctx.response,
+                                pathname: ctx.pathname,
+                                req: ctx.request,
+                                res: ctx.response,
+                                params: ctx.params || params || {},
+                                logger: ctx.logger || new Logger({
+                                    level: "warn"
+                                }),
+                                metrics: ctx.metrics || defaultMetrics,
+                                loadableStats: ctx.loadableStats,
+                                routeManifest: ctx.routeManifest
+                            })
+                        ];
+                    case 2:
+                        ctx.body = _state.sent();
+                        ctx.status = 200;
+                        return [
+                            2
+                        ];
+                    case 3:
+                        e = _state.sent();
+                        if (page.template) {
+                            ctx.body = page.template;
+                            ctx.status = 200;
+                            return [
+                                2
+                            ];
+                        } else {
+                            ctx.body = "404: not found";
+                            ctx.status = 404;
+                            return [
+                                2
+                            ];
+                        }
+                        return [
+                            3,
+                            4
+                        ];
+                    case 4:
+                        if (page.template) {
+                            ctx.body = page.template;
+                            ctx.status = 200;
+                            return [
+                                2
+                            ];
+                        }
+                        ctx.body = "404: not found";
+                        ctx.status = 404;
+                        return [
+                            2
+                        ];
+                }
+            });
+        });
+        return function(ctx) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+};
+export { createHandler, handleUrl };

package/dist/esm-node/constants.js ADDED Viewed

@@ -0,0 +1,35 @@
+const AGGRED_DIR = {
+  mock: "config/mock",
+  server: "server",
+  api: "api",
+  shared: "shared",
+  lambda: "lambda"
+};
+var ApiServerMode = /* @__PURE__ */ ((ApiServerMode2) => {
+  ApiServerMode2["func"] = "function";
+  ApiServerMode2["frame"] = "framework";
+  return ApiServerMode2;
+})(ApiServerMode || {});
+const ERROR_DIGEST = {
+  INIT: "Server init error",
+  ENOTF: "Page could not be found",
+  WARMUP: "SSR warmup failed",
+  EINTER: "Internal server error",
+  ERENDER: "SSR render failed",
+  EMICROINJ: "Get micro-frontend info failed"
+};
+const ERROR_PAGE_TEXT = {
+  404: "This page could not be found.",
+  500: "Internal Server Error."
+};
+const RUN_MODE = {
+  FULL: "full",
+  TYPE: "type"
+};
+export {
+  AGGRED_DIR,
+  ApiServerMode,
+  ERROR_DIGEST,
+  ERROR_PAGE_TEXT,
+  RUN_MODE
+};

package/dist/esm-node/index.js ADDED Viewed

@@ -0,0 +1,18 @@
+import { Server } from "./server";
+import { ModernServer } from "./server/modern-server";
+import { createProxyHandler } from "./libs/proxy";
+export * from "./type";
+export * from "./constants";
+var src_default = (options) => {
+  if (options == null) {
+    throw new Error("can not start mserver without options");
+  }
+  const server = new Server(options);
+  return server.init();
+};
+export {
+  ModernServer,
+  Server,
+  createProxyHandler,
+  src_default as default
+};

package/dist/esm-node/libs/context/context.js ADDED Viewed

@@ -0,0 +1,160 @@
+import { URL } from "url";
+import qs from "querystring";
+import { Buffer } from "buffer";
+import createEtag from "etag";
+import fresh from "fresh";
+import { headersWithoutCookie } from "../../utils";
+class ModernServerContext {
+  constructor(req, res, options) {
+    this.params = {};
+    this.options = {};
+    this.req = req;
+    this.res = res;
+    this.options = options || {};
+    this.serverData = {};
+    this.bind();
+  }
+  get logger() {
+    return this.req.logger;
+  }
+  get metrics() {
+    return this.req.metrics;
+  }
+  bind() {
+    const { req, res } = this;
+    req.get = (key) => this.getReqHeader(key);
+    res.set = (key, value) => this.res.setHeader(key, value);
+    res.send = (body) => {
+      this.send(body);
+    };
+  }
+  send(body) {
+    try {
+      const generateETag = !this.res.getHeader("ETag") && this.options.etag;
+      if (body !== void 0 && generateETag) {
+        const encoding = typeof body === "string" ? "utf-8" : void 0;
+        const buf = !Buffer.isBuffer(body) ? Buffer.from(body, encoding) : body;
+        const etag = createEtag(buf, { weak: true });
+        if (etag) {
+          this.res.setHeader("ETag", etag);
+        }
+      }
+      if (this.fresh) {
+        this.status = 304;
+      }
+    } catch (e) {
+      this.logger.error(e.message);
+    }
+    this.res.end(body);
+  }
+  setParams(params) {
+    this.params = params;
+  }
+  setServerData(key, value) {
+    this.serverData[key] = value;
+  }
+  getReqHeader(key) {
+    const { req } = this;
+    const field = key.toLowerCase();
+    switch (field) {
+      case "referer":
+      case "referrer":
+        return req.headers.referrer || req.headers.referer || "";
+      default:
+        return req.headers[field] || "";
+    }
+  }
+  get fresh() {
+    const { status, res, method } = this;
+    if ("GET" !== method && "HEAD" !== method) {
+      return false;
+    }
+    if (status >= 200 && status < 300 || 304 === status) {
+      return fresh(this.headers, {
+        etag: res.getHeader("ETag"),
+        "last-modified": res.getHeader("Last-Modified")
+      });
+    }
+    return false;
+  }
+  get headers() {
+    return this.req.headers;
+  }
+  get method() {
+    return this.req.method;
+  }
+  get url() {
+    return this.req.url || "";
+  }
+  set url(val) {
+    this.req.url = val;
+  }
+  get host() {
+    let host = this.getReqHeader("X-Forwarded-Host");
+    if (!host) {
+      host = this.getReqHeader("Host");
+    }
+    return host.split(/\s*,\s*/, 1)[0] || "";
+  }
+  get protocol() {
+    if (this.req.socket.encrypted) {
+      return "https";
+    }
+    const proto = this.getReqHeader("X-Forwarded-Proto");
+    return proto ? proto.split(/\s*,\s*/, 1)[0] : "http";
+  }
+  get origin() {
+    return `${this.protocol}://${this.host}`;
+  }
+  get href() {
+    return this.origin + this.url;
+  }
+  get parsedURL() {
+    const url = new URL(this.req.url, this.origin);
+    return url;
+  }
+  get path() {
+    return this.parsedURL.pathname;
+  }
+  set path(p) {
+    const url = new URL(this.req.url, this.origin);
+    if (!url || !p) {
+      return;
+    }
+    if (url.pathname === p) {
+      return;
+    }
+    url.pathname = p;
+    this.url = url.toString();
+  }
+  get querystring() {
+    if (!this.req) {
+      return "";
+    }
+    return this.parsedURL.search.replace(/^\?/, "") || "";
+  }
+  get query() {
+    const str = this.querystring;
+    return qs.parse(str);
+  }
+  get status() {
+    return this.res.statusCode;
+  }
+  set status(statusCode) {
+    this.res.statusCode = statusCode;
+  }
+  resHasHandled() {
+    return this.res.writableEnded;
+  }
+  error(dig, e = "") {
+    this.logger.error(
+      `Web Server Error - ${dig}, error = %s, req.url = %s, req.headers = %o`,
+      e instanceof Error ? e.stack || e.message : e,
+      this.path,
+      headersWithoutCookie(this.headers)
+    );
+  }
+}
+export {
+  ModernServerContext
+};

package/dist/esm-node/libs/context/index.js ADDED Viewed

@@ -0,0 +1,6 @@
+import { ModernServerContext } from "./context";
+const createContext = (req, res, options) => new ModernServerContext(req, res, options);
+export {
+  ModernServerContext,
+  createContext
+};