@modern-js/prod-server 2.8.0 → 2.9.1-alpha.0

package/dist/js/treeshaking/libs/hook-api/index.js

@@ -0,0 +1,281 @@
+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 _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+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 _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure 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 ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+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 cookie from "cookie";
+import { RouteAPI } from "./route";
+import { TemplateAPI } from "./template";
+var Response = /*#__PURE__*/ function() {
+    "use strict";
+    function Response(res) {
+        _classCallCheck(this, Response);
+        _defineProperty(this, "cookies", void 0);
+        _defineProperty(this, "res", void 0);
+        _defineProperty(this, "_cookie", void 0);
+        this.res = res;
+        this._cookie = cookie.parse(res.getHeader("set-cookie") || "");
+        this.cookies = {
+            get: this.getCookie.bind(this),
+            set: this.setCookie.bind(this),
+            delete: this.deleteCookie.bind(this),
+            clear: this.clearCookie.bind(this),
+            apply: this.applyCookie.bind(this)
+        };
+    }
+    _createClass(Response, [
+        {
+            key: "get",
+            value: function get(key) {
+                return this.res.getHeader(key);
+            }
+        },
+        {
+            key: "set",
+            value: function set(key, value) {
+                return this.res.setHeader(key, value);
+            }
+        },
+        {
+            key: "status",
+            value: function status(code) {
+                this.res.statusCode = code;
+            }
+        },
+        {
+            key: "getCookie",
+            value: function getCookie(key) {
+                return this._cookie[key];
+            }
+        },
+        {
+            key: "setCookie",
+            value: function setCookie(key, value) {
+                this._cookie[key] = value;
+            }
+        },
+        {
+            key: "deleteCookie",
+            value: function deleteCookie(key) {
+                if (this._cookie[key]) {
+                    delete this._cookie[key];
+                }
+            }
+        },
+        {
+            key: "clearCookie",
+            value: function clearCookie() {
+                this._cookie = {};
+            }
+        },
+        {
+            key: "applyCookie",
+            value: function applyCookie() {
+                var str = Object.entries(this._cookie).map(function(param) {
+                    var _param = _slicedToArray(param, 2), key = _param[0], value = _param[1];
+                    return cookie.serialize(key, value);
+                }).join("; ");
+                if (str) {
+                    this.res.setHeader("set-cookie", str);
+                } else {
+                    this.res.removeHeader("set-cookie");
+                }
+            }
+        },
+        {
+            key: "raw",
+            value: function raw(body, options) {
+                var _this = this;
+                var _ref = options || {}, status = _ref.status, _ref_headers = _ref.headers, headers = _ref_headers === void 0 ? {} : _ref_headers;
+                Object.entries(headers).forEach(function(param) {
+                    var _param = _slicedToArray(param, 2), key = _param[0], value = _param[1];
+                    _this.res.setHeader(key, value);
+                });
+                if (status) {
+                    this.res.statusCode = status;
+                }
+                this.res.end(body);
+            }
+        }
+    ]);
+    return Response;
+}();
+var Request = /*#__PURE__*/ function() {
+    "use strict";
+    function Request(ctx) {
+        _classCallCheck(this, Request);
+        _defineProperty(this, "url", void 0);
+        _defineProperty(this, "host", void 0);
+        _defineProperty(this, "pathname", void 0);
+        _defineProperty(this, "query", void 0);
+        _defineProperty(this, "headers", void 0);
+        _defineProperty(this, "cookie", void 0);
+        _defineProperty(this, "cookies", void 0);
+        _defineProperty(this, "_cookie", void 0);
+        this.url = ctx.url;
+        this.host = ctx.host;
+        this.pathname = ctx.path;
+        this.query = ctx.query;
+        this.headers = ctx.headers;
+        this.cookie = ctx.headers.cookie || "";
+        this._cookie = cookie.parse(this.cookie);
+        this.cookies = {
+            get: this.getCookie.bind(this)
+        };
+    }
+    _createClass(Request, [
+        {
+            key: "getCookie",
+            value: function getCookie(key) {
+                return this._cookie[key];
+            }
+        }
+    ]);
+    return Request;
+}();
+var base = function(context) {
+    var res = context.res;
+    return {
+        response: new Response(res),
+        request: new Request(context),
+        logger: context.logger,
+        metrics: context.metrics
+    };
+};
+var createAfterMatchContext = function(context, entryName) {
+    var baseContext = base(context);
+    return _objectSpreadProps(_objectSpread({}, baseContext), {
+        router: new RouteAPI(entryName)
+    });
+};
+var createAfterRenderContext = function(context, content) {
+    var baseContext = base(context);
+    return _objectSpreadProps(_objectSpread({}, baseContext), {
+        template: new TemplateAPI(content)
+    });
+};
+var createMiddlewareContext = function(context) {
+    var baseContext = base(context);
+    return _objectSpreadProps(_objectSpread({}, baseContext), {
+        response: _objectSpreadProps(_objectSpread({}, baseContext.response), {
+            locals: context.res.locals || {}
+        }),
+        source: {
+            req: context.req,
+            res: context.res
+        }
+    });
+};
+export { base, createAfterMatchContext, createAfterRenderContext, createMiddlewareContext };

package/dist/js/treeshaking/libs/hook-api/route.js

@@ -0,0 +1,68 @@
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+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;
+}
+var RouteAPI = /*#__PURE__*/ function() {
+    "use strict";
+    function RouteAPI(entryName) {
+        _classCallCheck(this, RouteAPI);
+        _defineProperty(this, "current", void 0);
+        _defineProperty(this, "status", void 0);
+        _defineProperty(this, "url", void 0);
+        this.current = entryName;
+        this.status = 200;
+        this.url = "";
+    }
+    _createClass(RouteAPI, [
+        {
+            key: "redirect",
+            value: function redirect(url) {
+                var status = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 302;
+                this.url = url;
+                this.status = status;
+            }
+        },
+        {
+            key: "rewrite",
+            value: function rewrite(entryName) {
+                this.current = entryName;
+            }
+        },
+        {
+            key: "use",
+            value: function use(entryName) {
+                this.rewrite(entryName);
+            }
+        }
+    ]);
+    return RouteAPI;
+}();
+export { RouteAPI };

package/dist/js/treeshaking/libs/hook-api/template.js

@@ -0,0 +1,127 @@
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+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;
+}
+import { Transform } from "stream";
+var RegList = {
+    before: {
+        head: "<head>",
+        body: "<body>"
+    },
+    after: {
+        head: "</head>",
+        body: "</body>"
+    }
+};
+var TemplateAPI = /*#__PURE__*/ function() {
+    "use strict";
+    function TemplateAPI(content) {
+        _classCallCheck(this, TemplateAPI);
+        _defineProperty(this, "content", void 0);
+        this.content = content;
+    }
+    _createClass(TemplateAPI, [
+        {
+            key: "get",
+            value: function get() {
+                return this.content;
+            }
+        },
+        {
+            key: "set",
+            value: function set(content) {
+                this.content = content;
+            }
+        },
+        {
+            key: "prependHead",
+            value: function prependHead(fragment) {
+                var head = RegList.before.head;
+                return this.replace(head, "".concat(head).concat(fragment));
+            }
+        },
+        {
+            key: "appendHead",
+            value: function appendHead(fragment) {
+                var head = RegList.after.head;
+                return this.replace(head, "".concat(fragment).concat(head));
+            }
+        },
+        {
+            key: "prependBody",
+            value: function prependBody(fragment) {
+                var body = RegList.before.body;
+                return this.replace(body, "".concat(body).concat(fragment));
+            }
+        },
+        {
+            key: "appendBody",
+            value: function appendBody(fragment) {
+                var body = RegList.after.body;
+                return this.replace(body, "".concat(fragment).concat(body));
+            }
+        },
+        {
+            key: "replace",
+            value: function replace(reg, text) {
+                this.content = this.content.replace(reg, text);
+            }
+        }
+    ]);
+    return TemplateAPI;
+}();
+var templateInjectableStream = function(param) {
+    var prependHead = param.prependHead, appendHead = param.appendHead, prependBody = param.prependBody, appendBody = param.appendBody;
+    return new Transform({
+        write: function write(chunk, _, callback) {
+            var chunk_str = chunk.toString();
+            if (prependHead) {
+                var head = RegList.before.head;
+                chunk_str = chunk_str.replace(head, "".concat(head).concat(prependHead));
+            }
+            if (appendHead) {
+                var head1 = RegList.after.head;
+                chunk_str = chunk_str.replace(head1, "".concat(appendHead).concat(head1));
+            }
+            if (prependBody) {
+                var body = RegList.before.body;
+                chunk_str = chunk_str.replace(body, "".concat(body).concat(prependBody));
+            }
+            if (appendBody) {
+                var body1 = RegList.after.body;
+                chunk_str = chunk_str.replace(body1, "".concat(appendBody).concat(body1));
+            }
+            this.push(chunk_str);
+            callback();
+        }
+    });
+};
+export { TemplateAPI, templateInjectableStream };

package/dist/js/treeshaking/libs/loadConfig.js

@@ -0,0 +1,82 @@
+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 _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 ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+import * as path from "path";
+import { compatRequire, fs, DEFAULT_SERVER_CONFIG } from "@modern-js/utils";
+import mergeDeep from "merge-deep";
+var getServerConfigPath = function(distDirectory) {
+    var serverConfigFile = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_SERVER_CONFIG;
+    var serverConfigPath = path.join(distDirectory, serverConfigFile);
+    return "".concat(serverConfigPath, ".js");
+};
+var requireConfig = function(serverConfigPath) {
+    if (fs.pathExistsSync(serverConfigPath)) {
+        return compatRequire(serverConfigPath);
+    }
+    return {};
+};
+var loadConfig = function(param) {
+    var cliConfig = param.cliConfig, serverConfig = param.serverConfig, resolvedConfigPath = param.resolvedConfigPath;
+    var config = null;
+    if (process.env.NODE_ENV === "production") {
+        var resolvedConfig = requireConfig(resolvedConfigPath);
+        config = mergeDeep(_objectSpreadProps(_objectSpread({}, resolvedConfig), {
+            plugins: []
+        }), serverConfig, cliConfig);
+    } else {
+        config = mergeDeep(_objectSpreadProps(_objectSpread({}, cliConfig), {
+            plugins: []
+        }), serverConfig);
+    }
+    return config;
+};
+export { getServerConfigPath, loadConfig, requireConfig };