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

package/dist/cjs/runtime/index.js

@@ -1,169 +1,157 @@
 "use strict";
-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,
-  hasFileExtension: () => hasFileExtension,
-  isRedirectResponse: () => isRedirectResponse,
-  isResponse: () => isResponse
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    hasFileExtension: ()=>hasFileExtension,
+    isRedirectResponse: ()=>isRedirectResponse,
+    isResponse: ()=>isResponse,
+    handleRequest: ()=>handleRequest
 });
-module.exports = __toCommonJS(runtime_exports);
-var import_browser = require("@modern-js/runtime-utils/browser");
-var import_node = require("@modern-js/runtime-utils/node");
-var import_node2 = require("@modern-js/runtime-utils/node");
-var import_remix_router = require("@modern-js/runtime-utils/remix-router");
-var import_server = require("@modern-js/runtime-utils/server");
-var import_time = require("@modern-js/runtime-utils/time");
-var import_request = require("@modern-js/runtime-utils/universal/request");
-var import_lodash = require("@modern-js/utils/lodash");
-var import_constants = require("@modern-js/utils/universal/constants");
-var import_constants2 = require("../common/constants");
-var import_errors = require("./errors");
-var import_response = require("./response");
-const redirectStatusCodes = /* @__PURE__ */ new Set([
-  301,
-  302,
-  303,
-  307,
-  308
+const browser_namespaceObject = require("@modern-js/runtime-utils/browser");
+const node_namespaceObject = require("@modern-js/runtime-utils/node");
+const router_namespaceObject = require("@modern-js/runtime-utils/router");
+const server_namespaceObject = require("@modern-js/runtime-utils/server");
+const time_namespaceObject = require("@modern-js/runtime-utils/time");
+const request_namespaceObject = require("@modern-js/runtime-utils/universal/request");
+const lodash_namespaceObject = require("@modern-js/utils/lodash");
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const constants_js_namespaceObject = require("../common/constants.js");
+const external_errors_js_namespaceObject = require("./errors.js");
+const external_response_js_namespaceObject = require("./response.js");
+const redirectStatusCodes = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
 ]);
 function isRedirectResponse(status) {
-  return redirectStatusCodes.has(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";
+    return null != value && 'number' == typeof value.status && 'string' == typeof value.statusText && 'object' == typeof value.headers && void 0 !== value.body;
 }
 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
-  });
+    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 lastSegment = pathname.split('/').pop() || '';
+    const dotIndex = lastSegment.lastIndexOf('.');
+    if (-1 === dotIndex) return false;
+    const extension = lastSegment.substring(dotIndex).toLowerCase();
+    return '.html' !== extension;
 }
-const handleRequest = async ({ request, serverRoutes, routes: routesConfig, context, onTiming }) => {
-  const url = new URL(request.url);
-  const routeId = url.searchParams.get(import_constants2.LOADER_ID_PARAM);
-  if (hasFileExtension(url.pathname)) {
-    return;
-  }
-  const entry = (0, import_server.matchEntry)(url.pathname, serverRoutes);
-  if (!routeId || !entry) {
-    return;
-  }
-  const basename = entry.urlPath;
-  const end = (0, import_time.time)();
-  const { reporter, loaderContext, monitors } = context;
-  const headersData = (0, import_request.parseHeaders)(request);
-  const activeDeferreds = /* @__PURE__ */ new Map();
-  return import_node2.storage.run({
-    headers: headersData,
-    monitors,
-    request,
-    activeDeferreds
-  }, async () => {
-    const routes = (0, import_browser.transformNestedRoutes)(routesConfig);
-    const { queryRoute } = (0, import_remix_router.createStaticHandler)(routes, {
-      basename
-    });
-    const requestContext = (0, import_node.createRequestContext)(loaderContext);
-    requestContext.set(import_node.reporterCtx, reporter);
-    let response;
-    try {
-      response = await queryRoute(request, {
-        routeId,
-        requestContext
-      });
-      if (isResponse(response) && isRedirectResponse(response.status)) {
-        response = convertModernRedirectResponse(response.headers, basename);
-      } else if ((0, import_lodash.isPlainObject)(response) && (import_remix_router.DEFERRED_SYMBOL in response || activeDeferreds.get(routeId))) {
-        let deferredData;
-        if (import_remix_router.DEFERRED_SYMBOL in response) {
-          deferredData = response[import_remix_router.DEFERRED_SYMBOL];
-        } else {
-          deferredData = activeDeferreds.get(routeId);
-        }
-        const body = (0, import_response.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", `${import_constants2.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 handleRequest = async ({ request, serverRoutes, routes: routesConfig, context, onTiming })=>{
+    const url = new URL(request.url);
+    const routeId = url.searchParams.get(constants_js_namespaceObject.LOADER_ID_PARAM);
+    if (hasFileExtension(url.pathname)) return;
+    const entry = (0, server_namespaceObject.matchEntry)(url.pathname, serverRoutes);
+    if (!routeId || !entry) return;
+    const basename = entry.urlPath;
+    const end = (0, time_namespaceObject.time)();
+    const { reporter, loaderContext, monitors } = context;
+    const headersData = (0, request_namespaceObject.parseHeaders)(request);
+    const activeDeferreds = new Map();
+    return node_namespaceObject.storage.run({
+        headers: headersData,
+        monitors,
+        request,
+        activeDeferreds
+    }, async ()=>{
+        const routes = (0, browser_namespaceObject.transformNestedRoutes)(routesConfig);
+        const { queryRoute } = (0, router_namespaceObject.createStaticHandler)(routes, {
+            basename
         });
-      }
-      const cost = end();
-      response.headers.set("X-Modernjs-Response", "yes");
-      onTiming === null || onTiming === void 0 ? void 0 : onTiming(`${import_constants.LOADER_REPORTER_NAME}-navigation`, cost);
-    } catch (error) {
-      if (isResponse(error)) {
-        error.headers.set("X-Modernjs-Catch", "yes");
-        response = error;
-      } else if ((0, import_remix_router.isRouteErrorResponse)(error)) {
-        response = (0, import_errors.errorResponseToJson)(error);
-      } else {
-        const errorInstance = error instanceof Error || error instanceof DOMException ? error : new Error("Unexpected Server Error");
-        response = new Response(JSON.stringify((0, import_errors.serializeError)(errorInstance)), {
-          status: 500,
-          headers: {
-            "X-Modernjs-Error": "yes",
-            "Content-Type": "application/json"
-          }
-        });
-      }
-    }
-    return response;
-  });
+        const requestContext = (0, node_namespaceObject.createRequestContext)(loaderContext);
+        requestContext.set(node_namespaceObject.reporterCtx, reporter);
+        let response;
+        try {
+            response = await queryRoute(request, {
+                routeId,
+                requestContext
+            });
+            if (isResponse(response) && isRedirectResponse(response.status)) response = convertModernRedirectResponse(response.headers, basename);
+            else if ((0, lodash_namespaceObject.isPlainObject)(response) && (router_namespaceObject.DEFERRED_SYMBOL in response || activeDeferreds.get(routeId))) {
+                let deferredData;
+                deferredData = router_namespaceObject.DEFERRED_SYMBOL in response ? response[router_namespaceObject.DEFERRED_SYMBOL] : activeDeferreds.get(routeId);
+                const body = (0, external_response_js_namespaceObject.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', `${constants_js_namespaceObject.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?.(`${constants_namespaceObject.LOADER_REPORTER_NAME}-navigation`, cost);
+        } catch (error) {
+            if (isResponse(error)) {
+                error.headers.set('X-Modernjs-Catch', 'yes');
+                response = error;
+            } else if ((0, router_namespaceObject.isRouteErrorResponse)(error)) response = (0, external_errors_js_namespaceObject.errorResponseToJson)(error);
+            else {
+                const errorInstance = error instanceof Error || error instanceof DOMException ? error : new Error('Unexpected Server Error');
+                response = new Response(JSON.stringify((0, external_errors_js_namespaceObject.serializeError)(errorInstance)), {
+                    status: 500,
+                    headers: {
+                        'X-Modernjs-Error': 'yes',
+                        'Content-Type': 'application/json'
+                    }
+                });
+            }
+        }
+        return response;
+    });
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  handleRequest,
-  hasFileExtension,
-  isRedirectResponse,
-  isResponse
+exports.handleRequest = __webpack_exports__.handleRequest;
+exports.hasFileExtension = __webpack_exports__.hasFileExtension;
+exports.isRedirectResponse = __webpack_exports__.isRedirectResponse;
+exports.isResponse = __webpack_exports__.isResponse;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "handleRequest",
+    "hasFileExtension",
+    "isRedirectResponse",
+    "isResponse"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/runtime/response.js

@@ -1,87 +1,76 @@
 "use strict";
-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
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createDeferredReadableStream: ()=>createDeferredReadableStream
 });
-module.exports = __toCommonJS(response_exports);
-var import_util = require("util");
-var import_node = require("@modern-js/runtime-utils/node");
+const external_util_namespaceObject = require("util");
+const node_namespaceObject = require("@modern-js/runtime-utils/node");
 function isTrackedPromise(value) {
-  return value != null && typeof value.then === "function" && value._tracked === true;
+    return null != value && 'function' == typeof value.then && true === value._tracked;
 }
-const DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
+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;
+    const encoder = new external_util_namespaceObject.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 (void 0 !== value._data || void 0 !== value._error) preresolvedKeys.push(key);
+            } else criticalData[key] = value;
+            controller.enqueue(encoder.encode(`${JSON.stringify(criticalData)}\n\n`));
+            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();
         }
-      }
-      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;
+    });
+    return stream;
 }
 function enqueueTrackedPromise(controller, encoder, settledKey, promise) {
-  if ("_error" in promise) {
-    const { _error } = promise;
-    controller.enqueue(encoder.encode(`error:${(0, import_node.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
-    })}
-
-`));
-  }
+    if ('_error' in promise) {
+        const { _error } = promise;
+        controller.enqueue(encoder.encode(`error:${(0, node_namespaceObject.serializeJson)({
+            [settledKey]: {
+                message: _error.message,
+                stack: _error.stack
+            }
+        })}\n\n`));
+    } else controller.enqueue(encoder.encode(`data:${JSON.stringify({
+        [settledKey]: promise._data ?? null
+    })}\n\n`));
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createDeferredReadableStream
+exports.createDeferredReadableStream = __webpack_exports__.createDeferredReadableStream;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDeferredReadableStream"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/esm/cli/createRequest.mjs

@@ -0,0 +1,93 @@
+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)=>res.headers.get('Content-Type')?.match(CONTENT_TYPE_DEFERRED) && res.body;
+const isRedirectResponse = (res)=>null != res.headers.get('X-Modernjs-Redirect');
+const isErrorResponse = (res)=>null != res.headers.get('X-Modernjs-Error');
+function isOtherErrorResponse(res) {
+    return res.status >= 400 && null == res.headers.get('X-Modernjs-Error') && null == res.headers.get('X-Modernjs-Catch') && null == res.headers.get('X-Modernjs-Response');
+}
+const isCatchResponse = (res)=>null != res.headers.get('X-Modernjs-Catch');
+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')=>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 deferredData.data;
+        }
+        if (isOtherErrorResponse(res)) return await handleNetworkErrorResponse(res);
+        return res;
+    };
+const createActionRequest = (routeId)=>async ({ params, request })=>{
+        const url = getRequestUrl({
+            params,
+            request,
+            routeId
+        });
+        const init = {
+            signal: request.signal
+        };
+        if ('GET' !== request.method) {
+            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 };