@modern-js/plugin-data-loader 2.5.0 → 2.7.0

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

@@ -15,15 +15,16 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var create_request_exports = {};
-__export(create_request_exports, {
+var createRequest_exports = {};
+__export(createRequest_exports, {
   createRequest: () => createRequest,
   getRequestUrl: () => getRequestUrl
 });
-module.exports = __toCommonJS(create_request_exports);
+module.exports = __toCommonJS(createRequest_exports);
 var import_path_to_regexp = require("path-to-regexp");
 var import_react_router_dom = require("react-router-dom");
 var import_constants = require("../common/constants");
+var import_data = require("./data");
 const getRequestUrl = ({
   params,
   request,
@@ -43,7 +44,14 @@ const handleRedirectResponse = (res) => {
   const { headers } = res;
   const location = headers.get("X-Modernjs-Redirect");
   if (location) {
-    return (0, import_react_router_dom.redirect)(location);
+    throw (0, import_react_router_dom.redirect)(location);
+  }
+  return res;
+};
+const handleDeferredResponse = async (res) => {
+  var _a;
+  if (((_a = res.headers.get("Content-Type")) == null ? void 0 : _a.match(import_constants.CONTENT_TYPE_DEFERRED)) && res.body) {
+    return await (0, import_data.parseDeferredReadableStream)(res.body);
   }
   return res;
 };
@@ -53,14 +61,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;
   };
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/cli/data.js

@@ -0,0 +1,162 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var data_exports = {};
+__export(data_exports, {
+  parseDeferredReadableStream: () => parseDeferredReadableStream
+});
+module.exports = __toCommonJS(data_exports);
+var import_remix_router = require("@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 import_remix_router.AbortedDeferredError(`Deferred ${key} will never resolved`)
+          );
+        }
+      } catch (error) {
+        for (const resolver of Object.values(deferredResolvers)) {
+          resolver.reject(error);
+        }
+      }
+    })();
+    return new import_remix_router.UNSAFE_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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseDeferredReadableStream
+});

package/dist/cjs/cli/{generate-client.js → generateClient.js}

@@ -17,15 +17,19 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var generate_client_exports = {};
-__export(generate_client_exports, {
+var generateClient_exports = {};
+__export(generateClient_exports, {
   generateClient: () => generateClient
 });
-module.exports = __toCommonJS(generate_client_exports);
+module.exports = __toCommonJS(generateClient_exports);
 var import_path = __toESM(require("path"));
 const generateClient = ({
   mapFile,
@@ -35,7 +39,7 @@ const generateClient = ({
   const loadersMap = require(mapFile);
   let requestCode = ``;
   let exportsCode = ``;
-  const requestCreatorPath = import_path.default.join(__dirname, "./create-request").replace("/cjs/cli/", "/esm/cli/").replace(/\\/g, "/");
+  const requestCreatorPath = import_path.default.join(__dirname, "./createRequest").replace("/cjs/cli/", "/esm/cli/").replace(/\\/g, "/");
   const importCode = `
     import { createRequest } from '${requestCreatorPath}';
   `;

package/dist/cjs/cli/loader.js

@@ -20,7 +20,7 @@ __export(loader_exports, {
   default: () => loader
 });
 module.exports = __toCommonJS(loader_exports);
-var import_generate_client = require("./generate-client");
+var import_generateClient = require("./generateClient");
 async function loader(source) {
   var _a;
   this.cacheable();
@@ -28,8 +28,11 @@ async function loader(source) {
   if (target === "node") {
     return source;
   }
+  if (target === "webworker") {
+    return source;
+  }
   const options = this.getOptions();
-  const code = (0, import_generate_client.generateClient)({
+  const code = (0, import_generateClient.generateClient)({
     mapFile: options.mapFile,
     loaderId: options.loaderId
   });

package/dist/cjs/common/constants.js

@@ -17,14 +17,17 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var constants_exports = {};
 __export(constants_exports, {
+  CONTENT_TYPE_DEFERRED: () => CONTENT_TYPE_DEFERRED,
   DIRECT_PARAM: () => DIRECT_PARAM,
   LOADER_ID_PARAM: () => LOADER_ID_PARAM
 });
 module.exports = __toCommonJS(constants_exports);
 const LOADER_ID_PARAM = "__loader";
 const DIRECT_PARAM = "__ssrDirect";
+const CONTENT_TYPE_DEFERRED = "text/modernjs-deferred";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CONTENT_TYPE_DEFERRED,
   DIRECT_PARAM,
   LOADER_ID_PARAM
 });

package/dist/cjs/runtime/index.js

@@ -0,0 +1,165 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtime_exports = {};
+__export(runtime_exports, {
+  handleRequest: () => handleRequest,
+  isRedirectResponse: () => isRedirectResponse,
+  isResponse: () => isResponse,
+  matchEntry: () => matchEntry
+});
+module.exports = __toCommonJS(runtime_exports);
+var import_node = require("@remix-run/node");
+var import_nestedRoutes = require("@modern-js/utils/nestedRoutes");
+var import_remix_router = require("@modern-js/utils/remix-router");
+var import_lodash = require("@modern-js/utils/lodash");
+var import_constants = require("../common/constants");
+var import_response = require("./response");
+(0, import_node.installGlobals)();
+const redirectStatusCodes = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+function isRedirectResponse(status) {
+  return redirectStatusCodes.has(status);
+}
+function isResponse(value) {
+  return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
+}
+function convertModernRedirectResponse(headers, basename) {
+  const newHeaders = new Headers(headers);
+  let redirectUrl = headers.get("Location");
+  if (basename !== "/") {
+    redirectUrl = redirectUrl.replace(basename, "");
+  }
+  newHeaders.set("X-Modernjs-Redirect", redirectUrl);
+  newHeaders.delete("Location");
+  return new import_node.Response(null, {
+    status: 204,
+    headers: newHeaders
+  });
+}
+const createLoaderHeaders = (requestHeaders) => {
+  const headers = new Headers();
+  for (const [key, values] of Object.entries(requestHeaders)) {
+    if (values) {
+      if (Array.isArray(values)) {
+        for (const value of values) {
+          headers.append(key, value);
+        }
+      } else {
+        headers.set(key, values);
+      }
+    }
+  }
+  return headers;
+};
+const createLoaderRequest = (context) => {
+  const origin = `${context.protocol}://${context.host}`;
+  const url = new URL(context.url, origin);
+  const controller = new AbortController();
+  const init = {
+    method: context.method,
+    headers: createLoaderHeaders(context.headers),
+    signal: controller.signal
+  };
+  return new Request(url.href, init);
+};
+const sendLoaderResponse = async (res, nodeResponse) => {
+  res.statusMessage = nodeResponse.statusText;
+  res.statusCode = nodeResponse.status;
+  for (const [key, value] of nodeResponse.headers.entries()) {
+    res.setHeader(key, value);
+  }
+  if (nodeResponse.body) {
+    await (0, import_node.writeReadableStreamToWritable)(nodeResponse.body, res);
+  } else {
+    res.end();
+  }
+};
+const matchEntry = (pathname, entries) => {
+  return entries.find((entry) => pathname.startsWith(entry.urlPath));
+};
+const handleRequest = async ({
+  context,
+  serverRoutes,
+  routes
+}) => {
+  const { method, query } = context;
+  const routeId = query[import_constants.LOADER_ID_PARAM];
+  const entry = matchEntry(context.path, serverRoutes);
+  if (!routeId || !entry) {
+    return;
+  }
+  if (method.toLowerCase() !== "get") {
+    throw new Error("CSR data loader request only support http GET method");
+  }
+  const basename = entry.urlPath;
+  const dataRoutes = (0, import_nestedRoutes.transformNestedRoutes)(routes);
+  const staticHandler = (0, import_remix_router.createStaticHandler)(dataRoutes, {
+    basename
+  });
+  const { res } = context;
+  const request = createLoaderRequest(context);
+  let response;
+  try {
+    response = await staticHandler.queryRoute(request, {
+      routeId,
+      requestContext: context
+    });
+    if (isResponse(response) && isRedirectResponse(response.status)) {
+      response = convertModernRedirectResponse(response.headers, basename);
+    } else if ((0, import_lodash.isPlainObject)(response) && import_remix_router.UNSAFE_DEFERRED_SYMBOL in response) {
+      const deferredData = response[import_remix_router.UNSAFE_DEFERRED_SYMBOL];
+      const body = (0, import_response.createDeferredReadableStream)(deferredData, request.signal);
+      const init = deferredData.init || {};
+      if (init.status && isRedirectResponse(init.status)) {
+        if (!init.headers) {
+          throw new Error("redirect response includes no headers");
+        }
+        response = convertModernRedirectResponse(
+          new Headers(init.headers),
+          basename
+        );
+      } else {
+        const headers = new Headers(init.headers);
+        headers.set("Content-Type", import_constants.CONTENT_TYPE_DEFERRED);
+        init.headers = headers;
+        response = new import_node.Response(body, init);
+      }
+    } else {
+      response = isResponse(response) ? response : new import_node.Response(JSON.stringify(response), {
+        headers: {
+          "Content-Type": "application/json; charset=utf-8"
+        }
+      });
+    }
+  } catch (error) {
+    const message = error instanceof import_remix_router.ErrorResponse ? error.data : String(error);
+    response = new import_node.Response(message, {
+      status: 500,
+      headers: {
+        "Content-Type": "text/plain"
+      }
+    });
+  }
+  sendLoaderResponse(res, response);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleRequest,
+  isRedirectResponse,
+  isResponse,
+  matchEntry
+});

package/dist/cjs/runtime/response.js

@@ -0,0 +1,102 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var response_exports = {};
+__export(response_exports, {
+  createDeferredReadableStream: () => createDeferredReadableStream
+});
+module.exports = __toCommonJS(response_exports);
+var import_util = require("util");
+var import_serialize = require("@modern-js/utils/serialize");
+function isTrackedPromise(value) {
+  return value != null && typeof value.then === "function" && value._tracked === true;
+}
+const DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
+function createDeferredReadableStream(deferredData, signal) {
+  const encoder = new import_util.TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const criticalData = {};
+      const preresolvedKeys = [];
+      for (const [key, value] of Object.entries(deferredData.data)) {
+        if (isTrackedPromise(value)) {
+          criticalData[key] = `${DEFERRED_VALUE_PLACEHOLDER_PREFIX}${key}`;
+          if (typeof value._data !== "undefined" || typeof value._error !== "undefined") {
+            preresolvedKeys.push(key);
+          }
+        } else {
+          criticalData[key] = value;
+        }
+      }
+      controller.enqueue(encoder.encode(`${JSON.stringify(criticalData)}
+
+`));
+      for (const preresolvedKey of preresolvedKeys) {
+        enqueueTrackedPromise(
+          controller,
+          encoder,
+          preresolvedKey,
+          deferredData.data[preresolvedKey]
+        );
+      }
+      const unsubscribe = deferredData.subscribe((aborted, settledKey) => {
+        if (settledKey) {
+          enqueueTrackedPromise(
+            controller,
+            encoder,
+            settledKey,
+            deferredData.data[settledKey]
+          );
+        }
+      });
+      await deferredData.resolveData(signal);
+      unsubscribe();
+      controller.close();
+    }
+  });
+  return stream;
+}
+function enqueueTrackedPromise(controller, encoder, settledKey, promise) {
+  var _a;
+  if ("_error" in promise) {
+    const { _error } = promise;
+    controller.enqueue(
+      encoder.encode(
+        `error:${(0, import_serialize.serializeJson)({
+          [settledKey]: {
+            message: _error.message,
+            stack: _error.stack
+          }
+        })}
+
+`
+      )
+    );
+  } else {
+    controller.enqueue(
+      encoder.encode(
+        `data:${JSON.stringify({ [settledKey]: (_a = promise._data) != null ? _a : null })}
+
+`
+      )
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDeferredReadableStream
+});