@modern-js/plugin-data-loader 0.0.0-next-20221209071922 → 0.0.0-next-20221209080421

package/dist/js/treeshaking/server/index.js

@@ -1,576 +1,316 @@
-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;
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import { installGlobals, writeReadableStreamToWritable, Response as NodeResponse } from '@remix-run/node';
+import { matchRoutes } from 'react-router-dom';
+import { LOADER_ROUTES_DIR } from '@modern-js/utils';
+// Polyfill Web Fetch API
+installGlobals();
+var LOADER_SEARCH_PARAM = '_loader';
+var redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
+export function isRedirectResponse(response) {
+  return redirectStatusCodes.has(response.status);
 }
-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);
-    }
+export function isResponse(value) {
+  return value != null && typeof value.status === 'number' && typeof value.statusText === 'string' && _typeof(value.headers) === 'object' && typeof value.body !== 'undefined';
 }
-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);
+var json = function json(data) {
+  var init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var responseInit = typeof init === 'number' ? {
+    status: init
+  } : init;
+  var headers = new Headers(responseInit.headers);
+  if (!headers.has('Content-Type')) {
+    headers.set('Content-Type', 'application/json; charset=utf-8');
+  }
+  return new NodeResponse(JSON.stringify(data), _objectSpread(_objectSpread({}, responseInit), {}, {
+    headers: headers
+  }));
+};
+
+// TODO: 添加 context
+var callRouteLoader = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+    var routeId, loader, params, request, loadContext, result;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            routeId = _ref.routeId, loader = _ref.loader, params = _ref.params, request = _ref.request, loadContext = _ref.loadContext;
+            if (loader) {
+              _context.next = 3;
+              break;
             }
-            function _throw(err) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            throw new Error("You made a ".concat(request.method, " request to ").concat(request.url, " but did not provide ") + "a default component or `loader` for route \"".concat(routeId, "\", ") + "so there is no way to handle the request.");
+          case 3:
+            _context.prev = 3;
+            _context.next = 6;
+            return loader({
+              request: request,
+              params: params
+            });
+          case 6:
+            result = _context.sent;
+            _context.next = 14;
+            break;
+          case 9:
+            _context.prev = 9;
+            _context.t0 = _context["catch"](3);
+            if (isResponse(_context.t0)) {
+              _context.next = 13;
+              break;
             }
-            _next(undefined);
-        });
-    };
-}
-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;
+            throw _context.t0;
+          case 13:
+            result = _context.t0;
+          case 14:
+            if (!(result === undefined)) {
+              _context.next = 16;
+              break;
+            }
+            throw new Error("You defined a loader for route \"".concat(routeId, "\" but didn't return ") + "anything from your `loader` function. Please return a value or `null`.");
+          case 16:
+            return _context.abrupt("return", isResponse(result) ? result : json(result));
+          case 17:
+          case "end":
+            return _context.stop();
         }
-    } catch (err) {
-        _d = true;
-        _e = err;
-    } finally{
+      }
+    }, _callee, null, [[3, 9]]);
+  }));
+  return function callRouteLoader(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+var createLoaderHeaders = function createLoaderHeaders(requestHeaders) {
+  var headers = new Headers();
+  for (var _i = 0, _Object$entries = Object.entries(requestHeaders); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      _key = _Object$entries$_i[0],
+      values = _Object$entries$_i[1];
+    if (values) {
+      if (Array.isArray(values)) {
+        var _iterator = _createForOfIteratorHelper(values),
+          _step;
         try {
-            if (!_n && _i["return"] != null) _i["return"]();
-        } finally{
-            if (_d) throw _e;
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var value = _step.value;
+            headers.append(_key, value);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
         }
+      } else {
+        headers.set(_key, values);
+      }
     }
-    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);
-}
-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;
+  }
+  return headers;
+};
+var createLoaderRequest = function createLoaderRequest(context) {
+  var origin = "".concat(context.protocol, "://").concat(context.host);
+  // eslint-disable-next-line node/no-unsupported-features/node-builtins, node/prefer-global/url
+  var url = new URL(context.url, origin);
+  var controller = new AbortController();
+  var init = {
+    method: context.method,
+    headers: createLoaderHeaders(context.headers),
+    signal: controller.signal
+  };
+  return new Request(url.href, init);
+};
+var sendLoaderResponse = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(res, nodeResponse) {
+    var _iterator2, _step2, _step2$value, _key2, value;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            res.statusMessage = nodeResponse.statusText;
+            res.statusCode = nodeResponse.status;
+            _iterator2 = _createForOfIteratorHelper(nodeResponse.headers.entries());
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                _step2$value = _slicedToArray(_step2.value, 2), _key2 = _step2$value[0], value = _step2$value[1];
+                res.setHeader(_key2, value);
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+            if (!nodeResponse.body) {
+              _context2.next = 9;
+              break;
             }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
+            _context2.next = 7;
+            return writeReadableStreamToWritable(nodeResponse.body, res);
+          case 7:
+            _context2.next = 10;
+            break;
+          case 9:
+            res.end();
+          case 10:
+          case "end":
+            return _context2.stop();
         }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
-    }
+      }
+    }, _callee2);
+  }));
+  return function sendLoaderResponse(_x2, _x3) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+export var getPathWithoutEntry = function getPathWithoutEntry(pathname, entryPath) {
+  if (entryPath === '/') {
+    return pathname;
+  }
+  return pathname.replace(entryPath, '');
 };
-import { installGlobals, writeReadableStreamToWritable, Response as NodeResponse } from "@remix-run/node";
-import { matchRoutes } from "react-router-dom";
-import { LOADER_ROUTES_DIR } from "@modern-js/utils";
-installGlobals();
-var LOADER_SEARCH_PARAM = "_loader";
-var redirectStatusCodes = /* @__PURE__ */ new Set([
-    301,
-    302,
-    303,
-    307,
-    308
-]);
-function isRedirectResponse(response) {
-    return redirectStatusCodes.has(response.status);
-}
-function isResponse(value) {
-    return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
-}
-var json = function(data) {
-    var init = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-    var responseInit = typeof init === "number" ? {
-        status: init
-    } : init;
-    var headers = new Headers(responseInit.headers);
-    if (!headers.has("Content-Type")) {
-        headers.set("Content-Type", "application/json; charset=utf-8");
-    }
-    return new NodeResponse(JSON.stringify(data), _objectSpreadProps(_objectSpread({}, responseInit), {
-        headers: headers
-    }));
+var matchEntry = function matchEntry(pathname, entries) {
+  return entries.find(function (entry) {
+    return pathname.startsWith(entry.urlPath);
+  });
 };
-var callRouteLoader = function() {
-    var _ref = _asyncToGenerator(function(param) {
-        var routeId, loader, params, request, loadContext, result, error;
-        return __generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    routeId = param.routeId, loader = param.loader, params = param.params, request = param.request, loadContext = param.loadContext;
-                    if (!loader) {
-                        throw new Error("You made a ".concat(request.method, " request to ").concat(request.url, ' but did not provide a default component or `loader` for route "').concat(routeId, '", so there is no way to handle the request.'));
-                    }
-                    _state.label = 1;
-                case 1:
-                    _state.trys.push([
-                        1,
-                        3,
-                        ,
-                        4
-                    ]);
-                    return [
-                        4,
-                        loader({
-                            request: request,
-                            params: params
-                        })
-                    ];
-                case 2:
-                    result = _state.sent();
-                    return [
-                        3,
-                        4
-                    ];
-                case 3:
-                    error = _state.sent();
-                    if (!isResponse(error)) {
-                        throw error;
-                    }
-                    result = error;
-                    return [
-                        3,
-                        4
-                    ];
-                case 4:
-                    if (result === void 0) {
-                        throw new Error('You defined a loader for route "'.concat(routeId, "\" but didn't return anything from your `loader` function. Please return a value or `null`."));
-                    }
-                    return [
-                        2,
-                        isResponse(result) ? result : json(result)
-                    ];
+export var handleRequest = /*#__PURE__*/function () {
+  var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref4) {
+    var context, serverRoutes, distDir, method, query, routeId, entry, _yield$import, routes, res, pathname, matches, match, request, response, headers, message;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            context = _ref4.context, serverRoutes = _ref4.serverRoutes, distDir = _ref4.distDir;
+            method = context.method, query = context.query;
+            routeId = query[LOADER_SEARCH_PARAM];
+            if (!(!routeId || method.toLowerCase() !== 'get')) {
+              _context3.next = 5;
+              break;
             }
-        });
-    });
-    return function callRouteLoader(_) {
-        return _ref.apply(this, arguments);
-    };
-}();
-var createLoaderHeaders = function(requestHeaders) {
-    var headers = new Headers();
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        for(var _iterator = Object.entries(requestHeaders)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var _value = _slicedToArray(_step.value, 2), key = _value[0], values = _value[1];
-            if (values) {
-                if (Array.isArray(values)) {
-                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-                    try {
-                        for(var _iterator1 = values[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-                            var value = _step1.value;
-                            headers.append(key, value);
-                        }
-                    } catch (err) {
-                        _didIteratorError1 = true;
-                        _iteratorError1 = err;
-                    } finally{
-                        try {
-                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                                _iterator1.return();
-                            }
-                        } finally{
-                            if (_didIteratorError1) {
-                                throw _iteratorError1;
-                            }
-                        }
-                    }
-                } else {
-                    headers.set(key, values);
-                }
+            return _context3.abrupt("return");
+          case 5:
+            entry = matchEntry(context.path, serverRoutes);
+            if (entry) {
+              _context3.next = 8;
+              break;
             }
-        }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
+            return _context3.abrupt("return");
+          case 8:
+            _context3.next = 10;
+            return import("".concat(distDir, "/").concat(LOADER_ROUTES_DIR, "/").concat(entry.entryName));
+          case 10:
+            _yield$import = _context3.sent;
+            routes = _yield$import.routes;
+            if (routes) {
+              _context3.next = 14;
+              break;
             }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
+            return _context3.abrupt("return");
+          case 14:
+            res = context.res;
+            pathname = getPathWithoutEntry(context.path, entry.urlPath);
+            matches = matchRoutes(routes, pathname);
+            if (matches) {
+              _context3.next = 21;
+              break;
             }
-        }
-    }
-    return headers;
-};
-var createLoaderRequest = function(context) {
-    var origin = "".concat(context.protocol, "://").concat(context.host);
-    var url = new URL(context.url, origin);
-    var controller = new AbortController();
-    var init = {
-        method: context.method,
-        headers: createLoaderHeaders(context.headers),
-        signal: controller.signal
-    };
-    return new Request(url.href, init);
-};
-var sendLoaderResponse = function() {
-    var _ref = _asyncToGenerator(function(res, nodeResponse) {
-        var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, key, value;
-        return __generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    res.statusMessage = nodeResponse.statusText;
-                    res.statusCode = nodeResponse.status;
-                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                    try {
-                        for(_iterator = nodeResponse.headers.entries()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                            _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
-                            res.setHeader(key, value);
-                        }
-                    } catch (err) {
-                        _didIteratorError = true;
-                        _iteratorError = err;
-                    } finally{
-                        try {
-                            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                _iterator.return();
-                            }
-                        } finally{
-                            if (_didIteratorError) {
-                                throw _iteratorError;
-                            }
-                        }
-                    }
-                    if (!nodeResponse.body) return [
-                        3,
-                        2
-                    ];
-                    return [
-                        4,
-                        writeReadableStreamToWritable(nodeResponse.body, res)
-                    ];
-                case 1:
-                    _state.sent();
-                    return [
-                        3,
-                        3
-                    ];
-                case 2:
-                    res.end();
-                    _state.label = 3;
-                case 3:
-                    return [
-                        2
-                    ];
+            res.statusCode = 403;
+            res.end("Route ".concat(pathname, " was not matched"));
+            return _context3.abrupt("return");
+          case 21:
+            match = matches === null || matches === void 0 ? void 0 : matches.find(function (match) {
+              return match.route.id === routeId;
+            });
+            if (match) {
+              _context3.next = 26;
+              break;
             }
-        });
-    });
-    return function sendLoaderResponse(res, nodeResponse) {
-        return _ref.apply(this, arguments);
-    };
-}();
-var getPathWithoutEntry = function(pathname, entryPath) {
-    if (entryPath === "/") {
-        return pathname;
-    }
-    return pathname.replace(entryPath, "");
-};
-var matchEntry = function(pathname, entries) {
-    return entries.find(function(entry) {
-        return pathname.startsWith(entry.urlPath);
-    });
-};
-var handleRequest = function() {
-    var _ref = _asyncToGenerator(function(param) {
-        var context, serverRoutes, distDir, method, query, routeId, entry, routes, res, pathname, matches, match, request, response, headers, error, message;
-        return __generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    context = param.context, serverRoutes = param.serverRoutes, distDir = param.distDir;
-                    method = context.method, query = context.query;
-                    routeId = query[LOADER_SEARCH_PARAM];
-                    if (!routeId || method.toLowerCase() !== "get") {
-                        return [
-                            2
-                        ];
-                    }
-                    entry = matchEntry(context.path, serverRoutes);
-                    if (!entry) {
-                        return [
-                            2
-                        ];
-                    }
-                    return [
-                        4,
-                        import("".concat(distDir, "/").concat(LOADER_ROUTES_DIR, "/").concat(entry.entryName))
-                    ];
-                case 1:
-                    routes = _state.sent().routes;
-                    if (!routes) {
-                        return [
-                            2
-                        ];
-                    }
-                    res = context.res;
-                    pathname = getPathWithoutEntry(context.path, entry.urlPath);
-                    matches = matchRoutes(routes, pathname);
-                    if (!matches) {
-                        res.statusCode = 403;
-                        res.end("Route ".concat(pathname, " was not matched"));
-                        return [
-                            2
-                        ];
-                    }
-                    match = matches === null || matches === void 0 ? void 0 : matches.find(function(match2) {
-                        return match2.route.id === routeId;
-                    });
-                    if (!match) {
-                        res.statusCode = 403;
-                        res.end("Route ".concat(routeId, " does not match URL ").concat(context.path));
-                        return [
-                            2
-                        ];
-                    }
-                    request = createLoaderRequest(context);
-                    _state.label = 2;
-                case 2:
-                    _state.trys.push([
-                        2,
-                        4,
-                        ,
-                        5
-                    ]);
-                    return [
-                        4,
-                        callRouteLoader({
-                            loader: match.route.loader,
-                            routeId: match.route.id,
-                            params: match.params,
-                            request: request,
-                            loadContext: {}
-                        })
-                    ];
-                case 3:
-                    response = _state.sent();
-                    if (isRedirectResponse(response)) {
-                        headers = new Headers(response.headers);
-                        headers.set("X-Modernjs-Redirect", headers.get("Location"));
-                        headers.delete("Location");
-                        response = new NodeResponse(null, {
-                            status: 204,
-                            headers: headers
-                        });
-                    }
-                    return [
-                        3,
-                        5
-                    ];
-                case 4:
-                    error = _state.sent();
-                    message = String(error);
-                    response = new NodeResponse(message, {
-                        status: 500,
-                        headers: {
-                            "Content-Type": "text/plain"
-                        }
-                    });
-                    return [
-                        3,
-                        5
-                    ];
-                case 5:
-                    sendLoaderResponse(res, response);
-                    return [
-                        2
-                    ];
+            res.statusCode = 403;
+            res.end("Route ".concat(routeId, " does not match URL ").concat(context.path));
+            return _context3.abrupt("return");
+          case 26:
+            request = createLoaderRequest(context);
+            _context3.prev = 27;
+            _context3.next = 30;
+            return callRouteLoader({
+              loader: match.route.loader,
+              routeId: match.route.id,
+              params: match.params,
+              request: request,
+              loadContext: {}
+            });
+          case 30:
+            response = _context3.sent;
+            if (isRedirectResponse(response)) {
+              headers = new Headers(response.headers);
+              headers.set('X-Modernjs-Redirect', headers.get('Location'));
+              headers["delete"]('Location');
+              response = new NodeResponse(null, {
+                status: 204,
+                headers: headers
+              });
             }
-        });
-    });
-    return function handleRequest(_) {
-        return _ref.apply(this, arguments);
-    };
+            _context3.next = 38;
+            break;
+          case 34:
+            _context3.prev = 34;
+            _context3.t0 = _context3["catch"](27);
+            message = String(_context3.t0);
+            response = new NodeResponse(message, {
+              status: 500,
+              headers: {
+                'Content-Type': 'text/plain'
+              }
+            });
+          case 38:
+            sendLoaderResponse(res, response);
+          case 39:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[27, 34]]);
+  }));
+  return function handleRequest(_x4) {
+    return _ref5.apply(this, arguments);
+  };
 }();
-var server_default = function() {
-    return {
-        name: "@modern-js/plugin-data-loader",
-        setup: function() {
-            return {
-                preparebeforeRouteHandler: function preparebeforeRouteHandler(param) {
-                    var serverRoutes = param.serverRoutes, distDir = param.distDir;
-                    return function() {
-                        var _ref = _asyncToGenerator(function(context) {
-                            return __generator(this, function(_state) {
-                                return [
-                                    2,
-                                    handleRequest({
-                                        serverRoutes: serverRoutes,
-                                        distDir: distDir,
-                                        context: context
-                                    })
-                                ];
-                            });
-                        });
-                        return function(context) {
-                            return _ref.apply(this, arguments);
-                        };
-                    }();
+export default (function () {
+  return {
+    name: '@modern-js/plugin-data-loader',
+    setup: function setup() {
+      return {
+        preparebeforeRouteHandler: function preparebeforeRouteHandler(_ref6) {
+          var serverRoutes = _ref6.serverRoutes,
+            distDir = _ref6.distDir;
+          return /*#__PURE__*/function () {
+            var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(context) {
+              return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+                while (1) {
+                  switch (_context4.prev = _context4.next) {
+                    case 0:
+                      return _context4.abrupt("return", handleRequest({
+                        serverRoutes: serverRoutes,
+                        distDir: distDir,
+                        context: context
+                      }));
+                    case 1:
+                    case "end":
+                      return _context4.stop();
+                  }
                 }
+              }, _callee4);
+            }));
+            return function (_x5) {
+              return _ref7.apply(this, arguments);
             };
+          }();
         }
-    };
-};
-export { server_default as default, getPathWithoutEntry, handleRequest, isRedirectResponse, isResponse };
+      };
+    }
+  };
+});