@modern-js/plugin-data-loader 2.69.5 → 3.0.0-alpha.0

package/dist/esm/runtime/errors.js

@@ -1,90 +0,0 @@
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
-import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
-import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
-import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
-import { isRouteErrorResponse } from "@modern-js/runtime-utils/remix-router";
-function sanitizeError(error) {
-  if (_instanceof(error, Error) && process.env.NODE_ENV !== "development" && process.env.NODE_ENV !== "test") {
-    var sanitized = new Error(error.message || "Unexpected Server Error");
-    sanitized.stack = void 0;
-    return sanitized;
-  }
-  return error;
-}
-function sanitizeErrors(errors) {
-  return Object.entries(errors).reduce(function(acc, param) {
-    var _param = _sliced_to_array(param, 2), routeId = _param[0], error = _param[1];
-    return Object.assign(acc, _define_property({}, routeId, sanitizeError(error)));
-  }, {});
-}
-function serializeError(error) {
-  var sanitized = sanitizeError(error);
-  return {
-    message: sanitized.message,
-    stack: sanitized.stack
-  };
-}
-function serializeErrors(errors) {
-  if (!errors) {
-    return null;
-  }
-  var entries = Object.entries(errors);
-  var serialized = {};
-  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-  try {
-    for (var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-      var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], val = _step_value[1];
-      if (isRouteErrorResponse(val)) {
-        serialized[key] = _object_spread_props(_object_spread({}, val), {
-          __type: "RouteErrorResponse"
-        });
-      } else if (_instanceof(val, Error)) {
-        var sanitized = sanitizeError(val);
-        serialized[key] = _object_spread({
-          message: sanitized.message,
-          stack: sanitized.stack,
-          __type: "Error"
-        }, sanitized.name !== "Error" ? {
-          __subType: sanitized.name
-        } : {});
-      } else {
-        serialized[key] = val;
-      }
-    }
-  } catch (err) {
-    _didIteratorError = true;
-    _iteratorError = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion && _iterator.return != null) {
-        _iterator.return();
-      }
-    } finally {
-      if (_didIteratorError) {
-        throw _iteratorError;
-      }
-    }
-  }
-  return serialized;
-}
-function errorResponseToJson(errorResponse) {
-  return Response.json(
-    // @ts-expect-error This is "private" from users but intended for internal use
-    serializeError(errorResponse.error || new Error("Unexpected Server Error")),
-    {
-      status: errorResponse.status,
-      statusText: errorResponse.statusText,
-      headers: {
-        "X-Modernjs-Error": "yes"
-      }
-    }
-  );
-}
-export {
-  errorResponseToJson,
-  sanitizeError,
-  sanitizeErrors,
-  serializeError,
-  serializeErrors
-};

package/dist/esm/runtime/index.js

@@ -1,191 +0,0 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
-import { _ as _type_of } from "@swc/helpers/_/_type_of";
-import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { transformNestedRoutes } from "@modern-js/runtime-utils/browser";
-import { createRequestContext, reporterCtx } from "@modern-js/runtime-utils/node";
-import { storage } from "@modern-js/runtime-utils/node";
-import { DEFERRED_SYMBOL, createStaticHandler, isRouteErrorResponse } from "@modern-js/runtime-utils/remix-router";
-import { matchEntry } from "@modern-js/runtime-utils/server";
-import { time } from "@modern-js/runtime-utils/time";
-import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
-import { isPlainObject } from "@modern-js/utils/lodash";
-import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
-import { CONTENT_TYPE_DEFERRED, LOADER_ID_PARAM } from "../common/constants";
-import { errorResponseToJson, serializeError } from "./errors";
-import { createDeferredReadableStream } from "./response";
-var 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" && _type_of(value.headers) === "object" && typeof value.body !== "undefined";
-}
-function convertModernRedirectResponse(headers, basename) {
-  var newHeaders = new Headers(headers);
-  var redirectUrl = headers.get("Location");
-  if (basename !== "/") {
-    redirectUrl = redirectUrl.replace(basename, "");
-  }
-  newHeaders.set("X-Modernjs-Redirect", redirectUrl);
-  newHeaders.delete("Location");
-  return new Response(null, {
-    status: 204,
-    headers: newHeaders
-  });
-}
-function hasFileExtension(pathname) {
-  var lastSegment = pathname.split("/").pop() || "";
-  var dotIndex = lastSegment.lastIndexOf(".");
-  if (dotIndex === -1) {
-    return false;
-  }
-  var extension = lastSegment.substring(dotIndex).toLowerCase();
-  return extension !== ".html";
-}
-var handleRequest = function() {
-  var _ref = _async_to_generator(function(param) {
-    var request, serverRoutes, routesConfig, context, onTiming, url, routeId, entry, basename, end, reporter, loaderContext, monitors, headersData, activeDeferreds;
-    return _ts_generator(this, function(_state) {
-      request = param.request, serverRoutes = param.serverRoutes, routesConfig = param.routes, context = param.context, onTiming = param.onTiming;
-      url = new URL(request.url);
-      routeId = url.searchParams.get(LOADER_ID_PARAM);
-      if (hasFileExtension(url.pathname)) {
-        return [
-          2
-        ];
-      }
-      entry = matchEntry(url.pathname, serverRoutes);
-      if (!routeId || !entry) {
-        return [
-          2
-        ];
-      }
-      basename = entry.urlPath;
-      end = time();
-      reporter = context.reporter, loaderContext = context.loaderContext, monitors = context.monitors;
-      headersData = parseHeaders(request);
-      activeDeferreds = /* @__PURE__ */ new Map();
-      return [
-        2,
-        storage.run({
-          headers: headersData,
-          monitors,
-          request,
-          activeDeferreds
-        }, /* @__PURE__ */ _async_to_generator(function() {
-          var routes, queryRoute, requestContext, response, deferredData, body, init, headers, cost, error, errorInstance;
-          return _ts_generator(this, function(_state2) {
-            switch (_state2.label) {
-              case 0:
-                routes = transformNestedRoutes(routesConfig);
-                queryRoute = createStaticHandler(routes, {
-                  basename
-                }).queryRoute;
-                requestContext = createRequestContext(loaderContext);
-                requestContext.set(reporterCtx, reporter);
-                _state2.label = 1;
-              case 1:
-                _state2.trys.push([
-                  1,
-                  3,
-                  ,
-                  4
-                ]);
-                return [
-                  4,
-                  queryRoute(request, {
-                    routeId,
-                    requestContext
-                  })
-                ];
-              case 2:
-                response = _state2.sent();
-                if (isResponse(response) && isRedirectResponse(response.status)) {
-                  response = convertModernRedirectResponse(response.headers, basename);
-                } else if (isPlainObject(response) && (DEFERRED_SYMBOL in response || activeDeferreds.get(routeId))) {
-                  ;
-                  if (DEFERRED_SYMBOL in response) {
-                    deferredData = response[DEFERRED_SYMBOL];
-                  } else {
-                    deferredData = activeDeferreds.get(routeId);
-                  }
-                  body = createDeferredReadableStream(
-                    // @ts-ignore
-                    deferredData,
-                    request.signal
-                  );
-                  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 {
-                    headers = new Headers(init.headers);
-                    headers.set("Content-Type", "".concat(CONTENT_TYPE_DEFERRED, "; charset=UTF-8"));
-                    init.headers = headers;
-                    response = new Response(body, init);
-                  }
-                } else {
-                  response = isResponse(response) ? response : new Response(JSON.stringify(response), {
-                    headers: {
-                      "Content-Type": "application/json; charset=utf-8"
-                    }
-                  });
-                }
-                cost = end();
-                response.headers.set("X-Modernjs-Response", "yes");
-                onTiming === null || onTiming === void 0 ? void 0 : onTiming("".concat(LOADER_REPORTER_NAME, "-navigation"), cost);
-                return [
-                  3,
-                  4
-                ];
-              case 3:
-                error = _state2.sent();
-                if (isResponse(error)) {
-                  error.headers.set("X-Modernjs-Catch", "yes");
-                  response = error;
-                } else if (isRouteErrorResponse(error)) {
-                  response = errorResponseToJson(error);
-                } else {
-                  errorInstance = _instanceof(error, Error) || _instanceof(error, DOMException) ? error : new Error("Unexpected Server Error");
-                  response = new Response(JSON.stringify(serializeError(errorInstance)), {
-                    status: 500,
-                    headers: {
-                      "X-Modernjs-Error": "yes",
-                      "Content-Type": "application/json"
-                    }
-                  });
-                }
-                return [
-                  3,
-                  4
-                ];
-              case 4:
-                return [
-                  2,
-                  response
-                ];
-            }
-          });
-        }))
-      ];
-    });
-  });
-  return function handleRequest2(_) {
-    return _ref.apply(this, arguments);
-  };
-}();
-export {
-  handleRequest,
-  hasFileExtension,
-  isRedirectResponse,
-  isResponse
-};

package/dist/esm/runtime/response.js

@@ -1,107 +0,0 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
-import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { TextEncoder } from "util";
-import { serializeJson } from "@modern-js/runtime-utils/node";
-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 _async_to_generator(function() {
-        var criticalData, preresolvedKeys, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, value, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, preresolvedKey, unsubscribe;
-        return _ts_generator(this, function(_state) {
-          switch (_state.label) {
-            case 0:
-              criticalData = {};
-              preresolvedKeys = [];
-              _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-              try {
-                for (_iterator = Object.entries(deferredData.data)[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                  _step_value = _sliced_to_array(_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 = void 0;
-              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(_define_property({}, settledKey, {
-      message: _error.message,
-      stack: _error.stack
-    })), "\n\n")));
-  } else {
-    var _promise__data;
-    controller.enqueue(encoder.encode("data:".concat(JSON.stringify(_define_property({}, settledKey, (_promise__data = promise._data) !== null && _promise__data !== void 0 ? _promise__data : null)), "\n\n")));
-  }
-}
-export {
-  createDeferredReadableStream
-};

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

@@ -1,126 +0,0 @@
-import { redirect } from "@modern-js/runtime-utils/router";
-import { compile } from "path-to-regexp";
-import { CONTENT_TYPE_DEFERRED, DIRECT_PARAM, LOADER_ID_PARAM } from "../common/constants";
-import { parseDeferredReadableStream } from "./data";
-const getRequestUrl = ({ params, request, routeId }) => {
-  const url = new URL(request.url);
-  const toPath = compile(url.pathname, {
-    encode: encodeURIComponent
-  });
-  const newPathName = toPath(params);
-  url.pathname = newPathName;
-  url.searchParams.append(LOADER_ID_PARAM, routeId);
-  url.searchParams.append(DIRECT_PARAM, "true");
-  return url;
-};
-const handleRedirectResponse = (res) => {
-  const { headers } = res;
-  const location = headers.get("X-Modernjs-Redirect");
-  if (location) {
-    throw redirect(location);
-  }
-  return res;
-};
-const isDeferredResponse = (res) => {
-  var _res_headers_get;
-  return ((_res_headers_get = res.headers.get("Content-Type")) === null || _res_headers_get === void 0 ? void 0 : _res_headers_get.match(CONTENT_TYPE_DEFERRED)) && res.body;
-};
-const isRedirectResponse = (res) => {
-  return res.headers.get("X-Modernjs-Redirect") != null;
-};
-const isErrorResponse = (res) => {
-  return res.headers.get("X-Modernjs-Error") != null;
-};
-function isOtherErrorResponse(res) {
-  return res.status >= 400 && res.headers.get("X-Modernjs-Error") == null && res.headers.get("X-Modernjs-Catch") == null && res.headers.get("X-Modernjs-Response") == null;
-}
-const isCatchResponse = (res) => {
-  return res.headers.get("X-Modernjs-Catch") != null;
-};
-const handleErrorResponse = async (res) => {
-  const data = await res.json();
-  const error = new Error(data.message);
-  error.stack = data.stack;
-  throw error;
-};
-const handleNetworkErrorResponse = async (res) => {
-  const text = await res.text();
-  const error = new Error(text);
-  error.stack = void 0;
-  throw error;
-};
-const createRequest = (routeId, method = "get") => {
-  const isRouterV7 = process.env._MODERN_ROUTER_VERSION === "v7";
-  return async ({ params, request }) => {
-    const url = getRequestUrl({
-      params,
-      request,
-      routeId
-    });
-    let res;
-    res = await fetch(url, {
-      method,
-      signal: request.signal
-    }).catch((error) => {
-      throw error;
-    });
-    if (isRedirectResponse(res)) {
-      return handleRedirectResponse(res);
-    }
-    if (isErrorResponse(res)) {
-      return await handleErrorResponse(res);
-    }
-    if (isCatchResponse(res)) {
-      throw res;
-    }
-    if (isDeferredResponse(res)) {
-      const deferredData = await parseDeferredReadableStream(res.body);
-      return isRouterV7 ? deferredData.data : deferredData;
-    }
-    if (isOtherErrorResponse(res)) {
-      return await handleNetworkErrorResponse(res);
-    }
-    return res;
-  };
-};
-const createActionRequest = (routeId) => {
-  return async ({ params, request }) => {
-    const url = getRequestUrl({
-      params,
-      request,
-      routeId
-    });
-    const init = {
-      signal: request.signal
-    };
-    if (request.method !== "GET") {
-      init.method = request.method;
-      const contentType = request.headers.get("Content-Type");
-      if (contentType && /\bapplication\/json\b/.test(contentType)) {
-        init.headers = {
-          "Content-Type": contentType
-        };
-        init.body = JSON.stringify(await request.json());
-      } else if (contentType && /\btext\/plain\b/.test(contentType)) {
-        init.headers = {
-          "Content-Type": contentType
-        };
-        init.body = await request.text();
-      } else if (contentType && /\bapplication\/x-www-form-urlencoded\b/.test(contentType)) {
-        init.body = new URLSearchParams(await request.text());
-      } else {
-        init.body = await request.formData();
-      }
-    }
-    const res = await fetch(url, init);
-    if (!res.ok) {
-      throw res;
-    }
-    return res;
-  };
-};
-export {
-  createActionRequest,
-  createRequest,
-  getRequestUrl
-};

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

@@ -1,140 +0,0 @@
-import { AbortedDeferredError, DeferredData } from "@modern-js/runtime-utils/browser";
-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/esm-node/cli/generateClient.js

@@ -1,32 +0,0 @@
-import path from "path";
-const generateClient = ({ inline, action, routeId }) => {
-  let requestCode = ``;
-  const requestCreatorPath = path.join(__dirname, "./createRequest").replace("/cjs/cli/", "/esm/cli/").replace(/\\/g, "/");
-  const importCode = `
-    import { createRequest, createActionRequest } from '${requestCreatorPath}';
-  `;
-  if (inline) {
-    if (action) {
-      requestCode = `
-      export const loader = createRequest('${routeId}');
-      export const action = createActionRequest('${routeId}')
-    `;
-    } else {
-      requestCode = `
-      export const loader = createRequest('${routeId}');
-    `;
-    }
-  } else {
-    requestCode = `
-    export default createRequest('${routeId}');
-  `;
-  }
-  const generatedCode = `
-    ${importCode}
-    ${requestCode}
-  `;
-  return generatedCode;
-};
-export {
-  generateClient
-};