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

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

@@ -1,47 +0,0 @@
-import { promisify } from "util";
-import { logger } from "@modern-js/utils/logger";
-import { generateClient } from "./generateClient";
-async function loader(source) {
-  var _this__compiler;
-  this.cacheable();
-  const target = (_this__compiler = this._compiler) === null || _this__compiler === void 0 ? void 0 : _this__compiler.options.target;
-  const shouldSkip = (compileTarget) => {
-    return target === compileTarget || Array.isArray(target) && target.includes(compileTarget);
-  };
-  if (shouldSkip("node") || shouldSkip("webworker") || shouldSkip("async-node")) {
-    return source;
-  }
-  const { resourceQuery } = this;
-  const options = resourceQuery.slice(1).split("&").reduce((pre, cur) => {
-    const [key, value] = cur.split("=");
-    if (key && value) {
-      pre[key] = value === "true" ? true : value === "false" ? false : value;
-    }
-    return pre;
-  }, {});
-  if (!options.loaderId || options.retain) {
-    return source;
-  }
-  if (options.clientData) {
-    const readFile = promisify(this.fs.readFile);
-    try {
-      const clientDataPath = this.resourcePath.includes(".loader.") ? this.resourcePath.replace(".loader.", ".data.client.") : this.resourcePath.replace(".data.", ".data.client.");
-      this.addDependency(clientDataPath);
-      const clientDataContent = await readFile(clientDataPath);
-      return clientDataContent;
-    } catch (error) {
-      if (process.env.NODE_ENV === "development") {
-        logger.error(`Failed to read the clientData file ${options.clientData}`);
-      }
-    }
-  }
-  const code = generateClient({
-    inline: options.inline,
-    action: options.action,
-    routeId: options.routeId
-  });
-  return code;
-}
-export {
-  loader as default
-};

package/dist/esm-node/common/constants.js

@@ -1,8 +0,0 @@
-const LOADER_ID_PARAM = "__loader";
-const DIRECT_PARAM = "__ssrDirect";
-const CONTENT_TYPE_DEFERRED = "text/modernjs-deferred";
-export {
-  CONTENT_TYPE_DEFERRED,
-  DIRECT_PARAM,
-  LOADER_ID_PARAM
-};

package/dist/esm-node/runtime/errors.js

@@ -1,75 +0,0 @@
-import { isRouteErrorResponse } from "@modern-js/runtime-utils/remix-router";
-function sanitizeError(error) {
-  if (error instanceof Error && process.env.NODE_ENV !== "development" && process.env.NODE_ENV !== "test") {
-    const sanitized = new Error(error.message || "Unexpected Server Error");
-    sanitized.stack = void 0;
-    return sanitized;
-  }
-  return error;
-}
-function sanitizeErrors(errors) {
-  return Object.entries(errors).reduce((acc, [routeId, error]) => {
-    return Object.assign(acc, {
-      [routeId]: sanitizeError(error)
-    });
-  }, {});
-}
-function serializeError(error) {
-  const sanitized = sanitizeError(error);
-  return {
-    message: sanitized.message,
-    stack: sanitized.stack
-  };
-}
-function serializeErrors(errors) {
-  if (!errors) {
-    return null;
-  }
-  const entries = Object.entries(errors);
-  const serialized = {};
-  for (const [key, val] of entries) {
-    if (isRouteErrorResponse(val)) {
-      serialized[key] = {
-        ...val,
-        __type: "RouteErrorResponse"
-      };
-    } else if (val instanceof Error) {
-      const sanitized = sanitizeError(val);
-      serialized[key] = {
-        message: sanitized.message,
-        stack: sanitized.stack,
-        __type: "Error",
-        // If this is a subclass (i.e., ReferenceError), send up the type so we
-        // can re-create the same type during hydration.  This will only apply
-        // in dev mode since all production errors are sanitized to normal
-        // Error instances
-        ...sanitized.name !== "Error" ? {
-          __subType: sanitized.name
-        } : {}
-      };
-    } else {
-      serialized[key] = val;
-    }
-  }
-  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-node/runtime/index.js

@@ -1,142 +0,0 @@
-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";
-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 Response(null, {
-    status: 204,
-    headers: newHeaders
-  });
-}
-function hasFileExtension(pathname) {
-  const lastSegment = pathname.split("/").pop() || "";
-  const dotIndex = lastSegment.lastIndexOf(".");
-  if (dotIndex === -1) {
-    return false;
-  }
-  const extension = lastSegment.substring(dotIndex).toLowerCase();
-  return extension !== ".html";
-}
-const handleRequest = async ({ request, serverRoutes, routes: routesConfig, context, onTiming }) => {
-  const url = new URL(request.url);
-  const routeId = url.searchParams.get(LOADER_ID_PARAM);
-  if (hasFileExtension(url.pathname)) {
-    return;
-  }
-  const entry = matchEntry(url.pathname, serverRoutes);
-  if (!routeId || !entry) {
-    return;
-  }
-  const basename = entry.urlPath;
-  const end = time();
-  const { reporter, loaderContext, monitors } = context;
-  const headersData = parseHeaders(request);
-  const activeDeferreds = /* @__PURE__ */ new Map();
-  return storage.run({
-    headers: headersData,
-    monitors,
-    request,
-    activeDeferreds
-  }, async () => {
-    const routes = transformNestedRoutes(routesConfig);
-    const { queryRoute } = createStaticHandler(routes, {
-      basename
-    });
-    const requestContext = createRequestContext(loaderContext);
-    requestContext.set(reporterCtx, reporter);
-    let response;
-    try {
-      response = await queryRoute(request, {
-        routeId,
-        requestContext
-      });
-      if (isResponse(response) && isRedirectResponse(response.status)) {
-        response = convertModernRedirectResponse(response.headers, basename);
-      } else if (isPlainObject(response) && (DEFERRED_SYMBOL in response || activeDeferreds.get(routeId))) {
-        let deferredData;
-        if (DEFERRED_SYMBOL in response) {
-          deferredData = response[DEFERRED_SYMBOL];
-        } else {
-          deferredData = activeDeferreds.get(routeId);
-        }
-        const body = createDeferredReadableStream(
-          // @ts-ignore
-          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", `${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"
-          }
-        });
-      }
-      const cost = end();
-      response.headers.set("X-Modernjs-Response", "yes");
-      onTiming === null || onTiming === void 0 ? void 0 : onTiming(`${LOADER_REPORTER_NAME}-navigation`, cost);
-    } catch (error) {
-      if (isResponse(error)) {
-        error.headers.set("X-Modernjs-Catch", "yes");
-        response = error;
-      } else if (isRouteErrorResponse(error)) {
-        response = errorResponseToJson(error);
-      } else {
-        const errorInstance = error instanceof Error || error instanceof 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 response;
-  });
-};
-export {
-  handleRequest,
-  hasFileExtension,
-  isRedirectResponse,
-  isResponse
-};

package/dist/esm-node/runtime/response.js

@@ -1,63 +0,0 @@
-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;
-}
-const DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
-function createDeferredReadableStream(deferredData, signal) {
-  const encoder = new 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) {
-  if ("_error" in promise) {
-    const { _error } = promise;
-    controller.enqueue(encoder.encode(`error:${serializeJson({
-      [settledKey]: {
-        message: _error.message,
-        stack: _error.stack
-      }
-    })}
-
-`));
-  } else {
-    var _promise__data;
-    controller.enqueue(encoder.encode(`data:${JSON.stringify({
-      [settledKey]: (_promise__data = promise._data) !== null && _promise__data !== void 0 ? _promise__data : null
-    })}
-
-`));
-  }
-}
-export {
-  createDeferredReadableStream
-};