@modern-js/plugin-data-loader 2.6.1-alpha.0 → 2.8.0

package/dist/esm/server/index.js

@@ -1,11 +1,3 @@
-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 asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -35,96 +27,6 @@ function _asyncToGenerator(fn) {
         });
     };
 }
-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);
-}
 var __generator = this && this.__generator || function(thisArg, body) {
     var f, y, t, g, _ = {
         label: 0,
@@ -221,347 +123,9 @@ var __generator = this && this.__generator || function(thisArg, body) {
     }
 };
 import path from "path";
-import { installGlobals, writeReadableStreamToWritable, Response as NodeResponse } from "@remix-run/node";
-import { matchRoutes } from "react-router-dom";
+import fs from "fs";
 import { MAIN_ENTRY_NAME, SERVER_BUNDLE_DIRECTORY } from "@modern-js/utils";
-import { LOADER_ID_PARAM } from "../common/constants";
-installGlobals();
-var redirectStatusCodes = /* @__PURE__ */ new Set([
-    301,
-    302,
-    303,
-    307,
-    308
-]);
-function sortByUrlPath(entries) {
-    entries.sort(function(a, b) {
-        var length1 = a.urlPath.length;
-        var length2 = b.urlPath.length;
-        if (length1 < length2) {
-            return 1;
-        }
-        if (length1 > length2) {
-            return -1;
-        }
-        return 0;
-    });
-    return entries;
-}
-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 callRouteLoader = function() {
-    var _ref = _asyncToGenerator(function(param) {
-        var routeId, loader, params, request, // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        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)
-                    ];
-            }
-        });
-    });
-    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 _step_value = _slicedToArray(_step.value, 2), key = _step_value[0], values = _step_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);
-                }
-            }
-        }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-            }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
-    }
-    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, _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){
-                            _step_value = _slicedToArray(_step.value, 2), key = _step_value[0], value = _step_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
-                    ];
-            }
-        });
-    });
-    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) {
-    var newEntries = sortByUrlPath(entries);
-    return newEntries.find(function(entry) {
-        return pathname.startsWith(entry.urlPath);
-    });
-};
-var handleRequest = function() {
-    var _ref = _asyncToGenerator(function(param) {
-        var context, serverRoutes, distDir, method, query, routeId, entry, routesPath, 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_ID_PARAM];
-                    if (!routeId || method.toLowerCase() !== "get") {
-                        return [
-                            2
-                        ];
-                    }
-                    entry = matchEntry(context.path, serverRoutes);
-                    if (!entry) {
-                        return [
-                            2
-                        ];
-                    }
-                    routesPath = path.join(distDir, SERVER_BUNDLE_DIRECTORY, "".concat(entry.entryName || MAIN_ENTRY_NAME, "-server-loaders"));
-                    return [
-                        4,
-                        import(routesPath)
-                    ];
-                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
-                    ];
-            }
-        });
-    });
-    return function handleRequest(_) {
-        return _ref.apply(this, arguments);
-    };
-}();
+import { matchEntry } from "../runtime";
 var server_default = function() {
     return {
         name: "@modern-js/plugin-data-loader",
@@ -571,15 +135,42 @@ var server_default = function() {
                     var serverRoutes = param.serverRoutes, distDir = param.distDir;
                     return function() {
                         var _ref = _asyncToGenerator(function(context) {
+                            var entry, routesPath, _ref, routes, handleRequest;
                             return __generator(this, function(_state) {
-                                return [
-                                    2,
-                                    handleRequest({
-                                        serverRoutes: serverRoutes,
-                                        distDir: distDir,
-                                        context: context
-                                    })
-                                ];
+                                switch(_state.label){
+                                    case 0:
+                                        entry = matchEntry(context.path, serverRoutes);
+                                        if (!entry) {
+                                            return [
+                                                2
+                                            ];
+                                        }
+                                        routesPath = path.join(distDir, SERVER_BUNDLE_DIRECTORY, "".concat(entry.entryName || MAIN_ENTRY_NAME, "-server-loaders.js"));
+                                        if (!fs.existsSync(routesPath)) {
+                                            return [
+                                                2
+                                            ];
+                                        }
+                                        return [
+                                            4,
+                                            import(routesPath)
+                                        ];
+                                    case 1:
+                                        _ref = _state.sent(), routes = _ref.routes, handleRequest = _ref.handleRequest;
+                                        if (!routes) {
+                                            return [
+                                                2
+                                            ];
+                                        }
+                                        return [
+                                            2,
+                                            handleRequest({
+                                                serverRoutes: serverRoutes,
+                                                context: context,
+                                                routes: routes
+                                            })
+                                        ];
+                                }
                             });
                         });
                         return function(context) {
@@ -591,4 +182,4 @@ var server_default = function() {
         }
     };
 };
-export { server_default as default, getPathWithoutEntry, handleRequest, isRedirectResponse, isResponse };
+export { server_default as default };

package/dist/esm-node/cli/{create-request.js → createRequest.js}

@@ -1,6 +1,11 @@
 import { compile } from "path-to-regexp";
 import { redirect } from "react-router-dom";
-import { LOADER_ID_PARAM, DIRECT_PARAM } from "../common/constants";
+import {
+  LOADER_ID_PARAM,
+  DIRECT_PARAM,
+  CONTENT_TYPE_DEFERRED
+} from "../common/constants";
+import { parseDeferredReadableStream } from "./data";
 const getRequestUrl = ({
   params,
   request,
@@ -20,7 +25,14 @@ const handleRedirectResponse = (res) => {
   const { headers } = res;
   const location = headers.get("X-Modernjs-Redirect");
   if (location) {
-    return redirect(location);
+    throw redirect(location);
+  }
+  return res;
+};
+const handleDeferredResponse = async (res) => {
+  var _a;
+  if (((_a = res.headers.get("Content-Type")) == null ? void 0 : _a.match(CONTENT_TYPE_DEFERRED)) && res.body) {
+    return await parseDeferredReadableStream(res.body);
   }
   return res;
 };
@@ -30,14 +42,17 @@ const createRequest = (routeId, method = "get") => {
     request
   }) => {
     const url = getRequestUrl({ params, request, routeId });
-    const res = await fetch(url, {
+    let res;
+    res = await fetch(url, {
       method,
       signal: request.signal
     });
     if (!res.ok) {
       throw res;
     }
-    return handleRedirectResponse(res);
+    res = handleRedirectResponse(res);
+    res = await handleDeferredResponse(res);
+    return res;
   };
 };
 export {

package/dist/esm-node/cli/data.js

@@ -0,0 +1,142 @@
+import {
+  UNSAFE_DeferredData as DeferredData,
+  AbortedDeferredError
+} from "@modern-js/utils/remix-router";
+const DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
+async function parseDeferredReadableStream(stream) {
+  if (!stream) {
+    throw new Error("parseDeferredReadableStream requires stream argument");
+  }
+  let deferredData;
+  const deferredResolvers = {};
+  try {
+    const sectionReader = readStreamSections(stream);
+    const initialSectionResult = await sectionReader.next();
+    const initialSection = initialSectionResult.value;
+    if (!initialSection) {
+      throw new Error("no critical data");
+    }
+    const criticalData = JSON.parse(initialSection);
+    if (typeof criticalData === "object" && criticalData !== null) {
+      for (const [eventKey, value] of Object.entries(criticalData)) {
+        if (typeof value !== "string" || !value.startsWith(DEFERRED_VALUE_PLACEHOLDER_PREFIX)) {
+          continue;
+        }
+        deferredData = deferredData || {};
+        deferredData[eventKey] = new Promise((resolve, reject) => {
+          deferredResolvers[eventKey] = {
+            resolve: (value2) => {
+              resolve(value2);
+              delete deferredResolvers[eventKey];
+            },
+            reject: (error) => {
+              reject(error);
+              delete deferredResolvers[eventKey];
+            }
+          };
+        });
+      }
+    }
+    (async () => {
+      try {
+        for await (const section of sectionReader) {
+          const [event, ...sectionDataStrings] = section.split(":");
+          const sectionDataString = sectionDataStrings.join(":");
+          const data = JSON.parse(sectionDataString);
+          if (event === "data") {
+            for (const [key, value] of Object.entries(data)) {
+              if (deferredResolvers[key]) {
+                deferredResolvers[key].resolve(value);
+              }
+            }
+          } else if (event === "error") {
+            for (const [key, value] of Object.entries(data)) {
+              const err = new Error(value.message);
+              err.stack = value.stack;
+              if (deferredResolvers[key]) {
+                deferredResolvers[key].reject(err);
+              }
+            }
+          }
+        }
+        for (const [key, resolver] of Object.entries(deferredResolvers)) {
+          resolver.reject(
+            new AbortedDeferredError(`Deferred ${key} will never resolved`)
+          );
+        }
+      } catch (error) {
+        for (const resolver of Object.values(deferredResolvers)) {
+          resolver.reject(error);
+        }
+      }
+    })();
+    return new DeferredData({ ...criticalData, ...deferredData });
+  } catch (error) {
+    for (const resolver of Object.values(deferredResolvers)) {
+      resolver.reject(error);
+    }
+    throw error;
+  }
+}
+async function* readStreamSections(stream) {
+  const reader = stream.getReader();
+  let buffer = [];
+  let sections = [];
+  let closed = false;
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const readStreamSection = async () => {
+    if (sections.length > 0) {
+      return sections.shift();
+    }
+    while (!closed && sections.length === 0) {
+      const chunk = await reader.read();
+      if (chunk.done) {
+        closed = true;
+        break;
+      }
+      buffer.push(chunk.value);
+      try {
+        const bufferedString = decoder.decode(mergeArrays(...buffer));
+        const splitSections = bufferedString.split("\n\n");
+        if (splitSections.length >= 2) {
+          sections.push(...splitSections.slice(0, -1));
+          buffer = [encoder.encode(splitSections.slice(-1).join("\n\n"))];
+        }
+        if (sections.length > 0) {
+          break;
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (sections.length > 0) {
+      return sections.shift();
+    }
+    if (buffer.length > 0) {
+      const bufferedString = decoder.decode(mergeArrays(...buffer));
+      sections = bufferedString.split("\n\n").filter((s) => s);
+      buffer = [];
+    }
+    return sections.shift();
+  };
+  let section = await readStreamSection();
+  while (section) {
+    yield section;
+    section = await readStreamSection();
+  }
+}
+function mergeArrays(...arrays) {
+  const out = new Uint8Array(
+    arrays.reduce((total, arr) => total + arr.length, 0)
+  );
+  let offset = 0;
+  for (const arr of arrays) {
+    out.set(arr, offset);
+    offset += arr.length;
+  }
+  return out;
+}
+export {
+  parseDeferredReadableStream
+};