@modern-js/plugin-data-loader 2.4.0 → 2.5.0-alpha.0

package/dist/esm/runtime/response.js

@@ -0,0 +1,284 @@
+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);
+        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);
+        });
+    };
+}
+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 _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;
+            }
+            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
+        };
+    }
+};
+import { TextEncoder } from "util";
+import { serializeJson } from "@modern-js/utils";
+function isTrackedPromise(value) {
+    return value != null && typeof value.then === "function" && value._tracked === true;
+}
+var DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
+function createDeferredReadableStream(deferredData, signal) {
+    var encoder = new TextEncoder();
+    var stream = new ReadableStream({
+        start: function start(controller) {
+            return _asyncToGenerator(function() {
+                var criticalData, preresolvedKeys, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, value, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, preresolvedKey, unsubscribe;
+                return __generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            criticalData = {};
+                            preresolvedKeys = [];
+                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                            try {
+                                for(_iterator = Object.entries(deferredData.data)[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                    _step_value = _slicedToArray(_step.value, 2), key = _step_value[0], value = _step_value[1];
+                                    if (isTrackedPromise(value)) {
+                                        criticalData[key] = "".concat(DEFERRED_VALUE_PLACEHOLDER_PREFIX).concat(key);
+                                        if (typeof value._data !== "undefined" || typeof value._error !== "undefined") {
+                                            preresolvedKeys.push(key);
+                                        }
+                                    } else {
+                                        criticalData[key] = value;
+                                    }
+                                }
+                            } catch (err) {
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                            }
+                            controller.enqueue(encoder.encode("".concat(JSON.stringify(criticalData), "\n\n")));
+                            _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                            try {
+                                for(_iterator1 = preresolvedKeys[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                    preresolvedKey = _step1.value;
+                                    enqueueTrackedPromise(controller, encoder, preresolvedKey, deferredData.data[preresolvedKey]);
+                                }
+                            } catch (err) {
+                                _didIteratorError1 = true;
+                                _iteratorError1 = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                        _iterator1.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError1) {
+                                        throw _iteratorError1;
+                                    }
+                                }
+                            }
+                            unsubscribe = deferredData.subscribe(function(aborted, settledKey) {
+                                if (settledKey) {
+                                    enqueueTrackedPromise(controller, encoder, settledKey, deferredData.data[settledKey]);
+                                }
+                            });
+                            return [
+                                4,
+                                deferredData.resolveData(signal)
+                            ];
+                        case 1:
+                            _state.sent();
+                            unsubscribe();
+                            controller.close();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        }
+    });
+    return stream;
+}
+function enqueueTrackedPromise(controller, encoder, settledKey, promise) {
+    if ("_error" in promise) {
+        var _error = promise._error;
+        controller.enqueue(encoder.encode("error:".concat(serializeJson(_defineProperty({}, settledKey, {
+            message: _error.message,
+            stack: _error.stack
+        })), "\n\n")));
+    } else {
+        var _promise__data;
+        controller.enqueue(encoder.encode("data:".concat(JSON.stringify(_defineProperty({}, settledKey, (_promise__data = promise._data) !== null && _promise__data !== void 0 ? _promise__data : null)), "\n\n")));
+    }
+}
+export { createDeferredReadableStream };

package/dist/esm/server/index.js

@@ -0,0 +1,176 @@
+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
+        };
+    }
+};
+import path from "path";
+import { MAIN_ENTRY_NAME, SERVER_BUNDLE_DIRECTORY } from "@modern-js/utils";
+import { matchEntry } from "../runtime";
+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) {
+                            var entry, routesPath, _ref, routes, handleRequest;
+                            return __generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        entry = matchEntry(context.path, serverRoutes);
+                                        if (!entry) {
+                                            throw new Error("Route is not matched");
+                                        }
+                                        routesPath = path.join(distDir, SERVER_BUNDLE_DIRECTORY, "".concat(entry.entryName || MAIN_ENTRY_NAME, "-server-loaders"));
+                                        return [
+                                            4,
+                                            import(routesPath)
+                                        ];
+                                    case 1:
+                                        _ref = _state.sent(), routes = _ref.routes, handleRequest = _ref.handleRequest;
+                                        if (!routes) {
+                                            throw new Error("Missing route info");
+                                            ;
+                                        }
+                                        return [
+                                            2,
+                                            handleRequest({
+                                                serverRoutes: serverRoutes,
+                                                context: context,
+                                                routes: routes
+                                            })
+                                        ];
+                                }
+                            });
+                        });
+                        return function(context) {
+                            return _ref.apply(this, arguments);
+                        };
+                    }();
+                }
+            };
+        }
+    };
+};
+export { server_default as default };

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

@@ -1,26 +1,7 @@
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 import { compile } from "path-to-regexp";
 import { redirect } from "react-router-dom";
 import { LOADER_ID_PARAM, DIRECT_PARAM } from "../common/constants";
+import { parseDeferredReadableStream } from "./data";
 const getRequestUrl = ({
   params,
   request,
@@ -40,25 +21,35 @@ 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(/text\/modernjs-deferred/)) && res.body) {
+    return await parseDeferredReadableStream(res.body);
   }
   return res;
 };
 const createRequest = (routeId, method = "get") => {
-  return (_0) => __async(void 0, [_0], function* ({
+  return async ({
     params,
     request
-  }) {
+  }) => {
     const url = getRequestUrl({ params, request, routeId });
-    const res = yield 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 {
   createRequest,

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
+};

package/dist/{js/modern → esm-node}/cli/generate-client.js

@@ -7,7 +7,7 @@ const generateClient = ({
   const loadersMap = require(mapFile);
   let requestCode = ``;
   let exportsCode = ``;
-  const requestCreatorPath = path.join(__dirname, "./create-request").replace("/node/cli/", "/treeshaking/cli/").replace(/\\/g, "/");
+  const requestCreatorPath = path.join(__dirname, "./create-request").replace("/cjs/cli/", "/esm/cli/").replace(/\\/g, "/");
   const importCode = `
     import { createRequest } from '${requestCreatorPath}';
   `;

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

@@ -0,0 +1,18 @@
+import { generateClient } from "./generate-client";
+async function loader(source) {
+  var _a;
+  this.cacheable();
+  const target = (_a = this._compiler) == null ? void 0 : _a.options.target;
+  if (target === "node") {
+    return source;
+  }
+  const options = this.getOptions();
+  const code = generateClient({
+    mapFile: options.mapFile,
+    loaderId: options.loaderId
+  });
+  return code;
+}
+export {
+  loader as default
+};