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

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

@@ -0,0 +1,52 @@
+import { isRouteErrorResponse } from "@modern-js/runtime-utils/router";
+function sanitizeError(error) {
+    if (error instanceof Error && 'development' !== process.env.NODE_ENV && 'test' !== process.env.NODE_ENV) {
+        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])=>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',
+            ...'Error' !== sanitized.name ? {
+                __subType: sanitized.name
+            } : {}
+        };
+    } else serialized[key] = val;
+    return serialized;
+}
+function errorResponseToJson(errorResponse) {
+    return Response.json(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.mjs

@@ -0,0 +1,114 @@
+import { transformNestedRoutes } from "@modern-js/runtime-utils/browser";
+import { createRequestContext, reporterCtx, storage } from "@modern-js/runtime-utils/node";
+import { DEFERRED_SYMBOL, createStaticHandler, isRouteErrorResponse } from "@modern-js/runtime-utils/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.mjs";
+import { errorResponseToJson, serializeError } from "./errors.mjs";
+import { createDeferredReadableStream } from "./response.mjs";
+const redirectStatusCodes = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+function isRedirectResponse(status) {
+    return redirectStatusCodes.has(status);
+}
+function isResponse(value) {
+    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
+    });
+}
+function hasFileExtension(pathname) {
+    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(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 = 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;
+                deferredData = DEFERRED_SYMBOL in response ? response[DEFERRED_SYMBOL] : activeDeferreds.get(routeId);
+                const body = 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', `${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?.(`${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.mjs

@@ -0,0 +1,42 @@
+import { TextEncoder } from "util";
+import { serializeJson } from "@modern-js/runtime-utils/node";
+function isTrackedPromise(value) {
+    return null != value && 'function' == typeof value.then && true === value._tracked;
+}
+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 (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();
+        }
+    });
+    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
+            }
+        })}\n\n`));
+    } else controller.enqueue(encoder.encode(`data:${JSON.stringify({
+        [settledKey]: promise._data ?? null
+    })}\n\n`));
+}
+export { createDeferredReadableStream };

package/dist/types/cli/createRequest.d.ts

@@ -1,4 +1,3 @@
-import type { DeferredData } from '@modern-js/runtime-utils/browser';
 export declare const getRequestUrl: ({ params, request, routeId, }: {
     params: Record<string, string>;
     request: Request;
@@ -7,7 +6,7 @@ export declare const getRequestUrl: ({ params, request, routeId, }: {
 export declare const createRequest: (routeId: string, method?: string) => ({ params, request, }: {
     params: Record<string, string>;
     request: Request;
-}) => Promise<DeferredData | Record<string, unknown> | Response>;
+}) => Promise<Record<string, unknown> | Response>;
 export declare const createActionRequest: (routeId: string) => ({ params, request, }: {
     params: Record<string, string>;
     request: Request;

package/dist/types/cli/loader.d.ts

@@ -1,4 +1,4 @@
-import type { LoaderContext } from 'webpack';
+import type { Rspack } from '@rsbuild/core';
 type Context = {
     mapFile: string;
     loaderId: string;
@@ -8,5 +8,5 @@ type Context = {
     routeId: string;
     retain: boolean;
 };
-export default function loader(this: LoaderContext<Context>, source: string): Promise<string | Buffer | undefined>;
+export default function loader(this: Rspack.LoaderContext<Context>, source: string): Promise<any>;
 export {};

package/dist/types/runtime/errors.d.ts

@@ -7,7 +7,7 @@
  * Copyright 2021 Remix Software Inc.
  * https://github.com/remix-run/remix/blob/main/LICENSE.md
  */
-import type { ErrorResponse, StaticHandlerContext } from '@modern-js/runtime-utils/remix-router';
+import type { ErrorResponse, StaticHandlerContext } from '@modern-js/runtime-utils/router';
 /**
  * This thing probably warrants some explanation.
  *

package/dist/types/runtime/response.d.ts

@@ -1,2 +1,2 @@
-import type { UNSAFE_DeferredData as DeferredData } from '@modern-js/runtime-utils/remix-router';
+import type { DeferredData } from '@modern-js/runtime-utils/browser';
 export declare function createDeferredReadableStream(deferredData: DeferredData, signal: AbortSignal): any;

package/package.json

@@ -15,14 +15,14 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.69.5",
+  "version": "3.0.0-alpha.0",
   "engines": {
-    "node": ">=16.2.0"
+    "node": ">=20"
   },
   "jsnext:source": "./src/runtime/index.ts",
   "types": "./dist/types/runtime/index.d.ts",
   "main": "./dist/cjs/runtime/index.js",
-  "module": "./dist/esm/runtime/index.js",
+  "module": "./dist/esm/runtime/index.mjs",
   "exports": {
     "./loader": {
       "types": "./dist/types/cli/loader.d.ts",
@@ -32,7 +32,7 @@
     "./runtime": {
       "types": "./dist/types/runtime/index.d.ts",
       "jsnext:source": "./src/runtime/index.ts",
-      "default": "./dist/esm/runtime/index.js"
+      "default": "./dist/esm/runtime/index.mjs"
     }
   },
   "typesVersions": {
@@ -46,34 +46,31 @@
     }
   },
   "dependencies": {
-    "@babel/core": "^7.26.0",
+    "@babel/core": "^7.28.5",
     "@swc/helpers": "^0.5.17",
     "path-to-regexp": "^6.3.0",
-    "@modern-js/runtime-utils": "2.69.5",
-    "@modern-js/utils": "2.69.5"
+    "@modern-js/runtime-utils": "3.0.0-alpha.0",
+    "@modern-js/utils": "3.0.0-alpha.0"
   },
   "devDependencies": {
+    "@rslib/core": "0.18.5",
     "@types/babel__core": "^7.20.5",
-    "@types/jest": "^29",
-    "@types/node": "^18",
-    "@types/supertest": "^2.0.11",
+    "@types/node": "^20",
+    "@types/supertest": "^2.0.16",
     "isomorphic-fetch": "^3.0.0",
-    "jest": "^29",
     "memfs": "^3.5.3",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "supertest": "^6.1.6",
-    "ts-jest": "^29.1.0",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "supertest": "^6.3.4",
     "typescript": "^5",
-    "webpack": "^5.103.0",
-    "@modern-js/server-core": "2.69.5",
-    "@modern-js/types": "2.69.5",
-    "@modern-js/core": "2.69.5",
-    "@scripts/build": "2.66.0",
-    "@scripts/jest-config": "2.66.0"
+    "@rsbuild/core": "1.6.15",
+    "@modern-js/types": "3.0.0-alpha.0",
+    "@scripts/rstest-config": "2.66.0",
+    "@modern-js/rslib": "2.68.10",
+    "@modern-js/server-core": "3.0.0-alpha.0"
   },
   "peerDependencies": {
-    "react": ">=17.0.0"
+    "react": ">=17.0.2"
   },
   "sideEffects": false,
   "publishConfig": {
@@ -81,9 +78,8 @@
     "access": "public"
   },
   "scripts": {
-    "new": "modern-lib new",
-    "build": "modern-lib build",
-    "dev": "modern-lib build --watch",
-    "test": "jest --passWithNoTests"
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "test": "rstest --passWithNoTests"
   }
 }

package/rslib.config.mts

@@ -0,0 +1,4 @@
+import { rslibConfig } from '@modern-js/rslib';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig(rslibConfig);

package/rstest.config.ts

@@ -0,0 +1,18 @@
+import { withTestPreset } from '@scripts/rstest-config';
+
+export default withTestPreset({
+  root: __dirname,
+  testEnvironment: 'node',
+  globals: true,
+  tools: {
+    swc: {
+      jsc: {
+        transform: {
+          react: {
+            runtime: 'automatic',
+          },
+        },
+      },
+    },
+  },
+});

package/dist/esm/cli/createRequest.js

@@ -1,297 +0,0 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-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";
-var getRequestUrl = function(param) {
-  var params = param.params, request = param.request, routeId = param.routeId;
-  var url = new URL(request.url);
-  var toPath = compile(url.pathname, {
-    encode: encodeURIComponent
-  });
-  var newPathName = toPath(params);
-  url.pathname = newPathName;
-  url.searchParams.append(LOADER_ID_PARAM, routeId);
-  url.searchParams.append(DIRECT_PARAM, "true");
-  return url;
-};
-var handleRedirectResponse = function(res) {
-  var headers = res.headers;
-  var location = headers.get("X-Modernjs-Redirect");
-  if (location) {
-    throw redirect(location);
-  }
-  return res;
-};
-var isDeferredResponse = function(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;
-};
-var isRedirectResponse = function(res) {
-  return res.headers.get("X-Modernjs-Redirect") != null;
-};
-var isErrorResponse = function(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;
-}
-var isCatchResponse = function(res) {
-  return res.headers.get("X-Modernjs-Catch") != null;
-};
-var handleErrorResponse = function() {
-  var _ref = _async_to_generator(function(res) {
-    var data, error;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return [
-            4,
-            res.json()
-          ];
-        case 1:
-          data = _state.sent();
-          error = new Error(data.message);
-          error.stack = data.stack;
-          throw error;
-      }
-    });
-  });
-  return function handleErrorResponse2(res) {
-    return _ref.apply(this, arguments);
-  };
-}();
-var handleNetworkErrorResponse = function() {
-  var _ref = _async_to_generator(function(res) {
-    var text, error;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return [
-            4,
-            res.text()
-          ];
-        case 1:
-          text = _state.sent();
-          error = new Error(text);
-          error.stack = void 0;
-          throw error;
-      }
-    });
-  });
-  return function handleNetworkErrorResponse2(res) {
-    return _ref.apply(this, arguments);
-  };
-}();
-var createRequest = function(routeId) {
-  var method = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "get";
-  var isRouterV7 = process.env._MODERN_ROUTER_VERSION === "v7";
-  return function() {
-    var _ref = _async_to_generator(function(param) {
-      var params, request, url, res, deferredData;
-      return _ts_generator(this, function(_state) {
-        switch (_state.label) {
-          case 0:
-            params = param.params, request = param.request;
-            url = getRequestUrl({
-              params,
-              request,
-              routeId
-            });
-            return [
-              4,
-              fetch(url, {
-                method,
-                signal: request.signal
-              }).catch(function(error) {
-                throw error;
-              })
-            ];
-          case 1:
-            res = _state.sent();
-            if (isRedirectResponse(res)) {
-              return [
-                2,
-                handleRedirectResponse(res)
-              ];
-            }
-            if (!isErrorResponse(res))
-              return [
-                3,
-                3
-              ];
-            return [
-              4,
-              handleErrorResponse(res)
-            ];
-          case 2:
-            return [
-              2,
-              _state.sent()
-            ];
-          case 3:
-            if (isCatchResponse(res)) {
-              throw res;
-            }
-            if (!isDeferredResponse(res))
-              return [
-                3,
-                5
-              ];
-            return [
-              4,
-              parseDeferredReadableStream(res.body)
-            ];
-          case 4:
-            deferredData = _state.sent();
-            return [
-              2,
-              isRouterV7 ? deferredData.data : deferredData
-            ];
-          case 5:
-            if (!isOtherErrorResponse(res))
-              return [
-                3,
-                7
-              ];
-            return [
-              4,
-              handleNetworkErrorResponse(res)
-            ];
-          case 6:
-            return [
-              2,
-              _state.sent()
-            ];
-          case 7:
-            return [
-              2,
-              res
-            ];
-        }
-      });
-    });
-    return function(_) {
-      return _ref.apply(this, arguments);
-    };
-  }();
-};
-var createActionRequest = function(routeId) {
-  return function() {
-    var _ref = _async_to_generator(function(param) {
-      var params, request, url, init, contentType, _, _1, res;
-      return _ts_generator(this, function(_state) {
-        switch (_state.label) {
-          case 0:
-            params = param.params, request = param.request;
-            url = getRequestUrl({
-              params,
-              request,
-              routeId
-            });
-            init = {
-              signal: request.signal
-            };
-            if (!(request.method !== "GET"))
-              return [
-                3,
-                8
-              ];
-            init.method = request.method;
-            contentType = request.headers.get("Content-Type");
-            if (!(contentType && /\bapplication\/json\b/.test(contentType)))
-              return [
-                3,
-                2
-              ];
-            init.headers = {
-              "Content-Type": contentType
-            };
-            _ = JSON.stringify;
-            return [
-              4,
-              request.json()
-            ];
-          case 1:
-            init.body = _.apply(JSON, [
-              _state.sent()
-            ]);
-            return [
-              3,
-              8
-            ];
-          case 2:
-            if (!(contentType && /\btext\/plain\b/.test(contentType)))
-              return [
-                3,
-                4
-              ];
-            init.headers = {
-              "Content-Type": contentType
-            };
-            return [
-              4,
-              request.text()
-            ];
-          case 3:
-            init.body = _state.sent();
-            return [
-              3,
-              8
-            ];
-          case 4:
-            if (!(contentType && /\bapplication\/x-www-form-urlencoded\b/.test(contentType)))
-              return [
-                3,
-                6
-              ];
-            _1 = URLSearchParams.bind;
-            return [
-              4,
-              request.text()
-            ];
-          case 5:
-            init.body = new (_1.apply(URLSearchParams, [
-              void 0,
-              _state.sent()
-            ]))();
-            return [
-              3,
-              8
-            ];
-          case 6:
-            return [
-              4,
-              request.formData()
-            ];
-          case 7:
-            init.body = _state.sent();
-            _state.label = 8;
-          case 8:
-            return [
-              4,
-              fetch(url, init)
-            ];
-          case 9:
-            res = _state.sent();
-            if (!res.ok) {
-              throw res;
-            }
-            return [
-              2,
-              res
-            ];
-        }
-      });
-    });
-    return function(_) {
-      return _ref.apply(this, arguments);
-    };
-  }();
-};
-export {
-  createActionRequest,
-  createRequest,
-  getRequestUrl
-};