@modern-js/plugin-data-loader 2.35.0 → 2.35.2-alpha.0

package/dist/cjs/runtime/response.js

@@ -1,21 +1,34 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "createDeferredReadableStream", {
-  enumerable: true,
-  get: function() {
-    return createDeferredReadableStream;
+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
 });
-const _util = require("util");
-const _runtimenode = require("@modern-js/utils/runtime-node");
+module.exports = __toCommonJS(response_exports);
+var import_util = require("util");
+var import_node = require("@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 _util.TextEncoder();
+  const encoder = new import_util.TextEncoder();
   const stream = new ReadableStream({
     async start(controller) {
       const criticalData = {};
@@ -51,7 +64,7 @@ function createDeferredReadableStream(deferredData, signal) {
 function enqueueTrackedPromise(controller, encoder, settledKey, promise) {
   if ("_error" in promise) {
     const { _error } = promise;
-    controller.enqueue(encoder.encode(`error:${(0, _runtimenode.serializeJson)({
+    controller.enqueue(encoder.encode(`error:${(0, import_node.serializeJson)({
       [settledKey]: {
         message: _error.message,
         stack: _error.stack
@@ -68,3 +81,7 @@ function enqueueTrackedPromise(controller, encoder, settledKey, promise) {
 `));
   }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDeferredReadableStream
+});

package/dist/cjs/server/index.js

@@ -1,33 +1,54 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function() {
-    return _default;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __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 server_exports = {};
+__export(server_exports, {
+  default: () => server_default
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _fs = /* @__PURE__ */ _interop_require_default._(require("fs"));
-const _utils = require("@modern-js/utils");
-const _runtimenode = require("@modern-js/utils/runtime-node");
-const _default = () => ({
+module.exports = __toCommonJS(server_exports);
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+var import_utils = require("@modern-js/utils");
+var import_node = require("@modern-js/runtime-utils/node");
+var server_default = () => ({
   name: "@modern-js/plugin-data-loader",
   setup: () => ({
     prepareLoaderHandler({ serverRoutes, distDir }) {
       return async (context) => {
-        const entry = (0, _runtimenode.matchEntry)(context.path, serverRoutes);
+        const entry = (0, import_node.matchEntry)(context.path, serverRoutes);
         if (!entry) {
           return;
         }
-        const routesPath = _path.default.join(distDir, _utils.SERVER_BUNDLE_DIRECTORY, `${entry.entryName || _utils.MAIN_ENTRY_NAME}-server-loaders.js`);
-        if (!_fs.default.existsSync(routesPath)) {
+        const routesPath = import_path.default.join(distDir, import_utils.SERVER_BUNDLE_DIRECTORY, `${entry.entryName || import_utils.MAIN_ENTRY_NAME}-server-loaders.js`);
+        if (!import_fs.default.existsSync(routesPath)) {
           return;
         }
-        const { routes, handleRequest } = await Promise.resolve(routesPath).then((p) => /* @__PURE__ */ _interop_require_wildcard._(require(p)));
+        const { routes, handleRequest } = await Promise.resolve().then(() => __toESM(require(routesPath)));
         if (!routes) {
           return;
         }

package/dist/esm/cli/createRequest.js

@@ -1,10 +1,10 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { compile } from "path-to-regexp";
-import { redirect } from "@modern-js/utils/runtime/router";
+import { redirect } from "@modern-js/runtime-utils/router";
 import { LOADER_ID_PARAM, DIRECT_PARAM, CONTENT_TYPE_DEFERRED } from "../common/constants";
 import { parseDeferredReadableStream } from "./data";
-export var getRequestUrl = function(param) {
+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, {
@@ -56,7 +56,7 @@ var handleDeferredResponse = function() {
     return _ref.apply(this, arguments);
   };
 }();
-export var createRequest = function(routeId) {
+var createRequest = function(routeId) {
   var method = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "get";
   return function() {
     var _ref = _async_to_generator(function(param) {
@@ -66,14 +66,14 @@ export var createRequest = function(routeId) {
           case 0:
             params = param.params, request = param.request;
             url = getRequestUrl({
-              params: params,
-              request: request,
-              routeId: routeId
+              params,
+              request,
+              routeId
             });
             return [
               4,
               fetch(url, {
-                method: method,
+                method,
                 signal: request.signal
               })
             ];
@@ -101,3 +101,121 @@ export var createRequest = function(routeId) {
     };
   }();
 };
+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
+};

package/dist/esm/cli/data.js

@@ -7,9 +7,9 @@ import { _ as _to_array } from "@swc/helpers/_/_to_array";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _wrap_async_generator } from "@swc/helpers/_/_wrap_async_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { UNSAFE_DeferredData as DeferredData, AbortedDeferredError } from "@modern-js/utils/runtime/remix-router";
+import { UNSAFE_DeferredData as DeferredData, AbortedDeferredError } from "@modern-js/runtime-utils/remix-router";
 var DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
-export function parseDeferredReadableStream(stream) {
+function parseDeferredReadableStream(stream) {
   return _parseDeferredReadableStream.apply(this, arguments);
 }
 function _parseDeferredReadableStream() {
@@ -485,3 +485,6 @@ function mergeArrays() {
   }
   return out;
 }
+export {
+  parseDeferredReadableStream
+};

package/dist/esm/cli/generateClient.js

@@ -1,44 +1,21 @@
 import path from "path";
-export var generateClient = function(param) {
-  var mapFile = param.mapFile, loaderId = param.loaderId;
-  delete require.cache[mapFile];
-  var loadersMap = require(mapFile);
+var generateClient = function(param) {
+  var inline = param.inline, action = param.action, routeId = param.routeId;
   var requestCode = "";
-  var exportsCode = "";
   var requestCreatorPath = path.join(__dirname, "./createRequest").replace("/cjs/cli/", "/esm/cli/").replace(/\\/g, "/");
-  var importCode = "\n    import { createRequest } from '".concat(requestCreatorPath, "';\n  ");
-  if (!loaderId) {
-    requestCode = Object.keys(loadersMap).map(function(loaderId2) {
-      var routeId = loadersMap[loaderId2].routeId;
-      return "\n      const ".concat(loaderId2, " = createRequest('").concat(routeId, "');\n    ");
-    }).join("");
-    exportsCode = "export {";
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-    try {
-      for (var _iterator = Object.keys(loadersMap)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var loader = _step.value;
-        exportsCode += "".concat(loader, ",");
-      }
-    } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator.return != null) {
-          _iterator.return();
-        }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
-        }
-      }
+  var importCode = "\n    import { createRequest, createActionRequest } from '".concat(requestCreatorPath, "';\n  ");
+  if (inline) {
+    if (action) {
+      requestCode = "\n      export const loader = createRequest('".concat(routeId, "');\n      export const action = createActionRequest('").concat(routeId, "')\n    ");
+    } else {
+      requestCode = "\n      export const loader = createRequest('".concat(routeId, "');\n    ");
     }
-    exportsCode += "}";
   } else {
-    var loader1 = loadersMap[loaderId];
-    requestCode = "\n      const loader = createRequest('".concat(loader1.routeId, "');\n    ");
-    exportsCode = "export default loader;";
+    requestCode = "\n    export default createRequest('".concat(routeId, "');\n  ");
   }
-  var generatedCode = "\n    ".concat(importCode, "\n    ").concat(requestCode, "\n    ").concat(exportsCode, "\n  ");
+  var generatedCode = "\n    ".concat(importCode, "\n    ").concat(requestCode, "\n  ");
   return generatedCode;
 };
+export {
+  generateClient
+};

package/dist/esm/cli/loader.js

@@ -4,7 +4,7 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { promisify } from "util";
 import { logger } from "@modern-js/utils/logger";
 import { generateClient } from "./generateClient";
-export default function loader(source) {
+function loader(source) {
   return _loader.apply(this, arguments);
 }
 function _loader() {
@@ -28,17 +28,14 @@ function _loader() {
             ];
           }
           resourceQuery = this.resourceQuery;
-          options = resourceQuery.slice(1).split("&").map(function(item) {
-            return item.split("=");
-          }).reduce(function(pre, cur) {
-            var _cur = _sliced_to_array(cur, 2), key = _cur[0], value = _cur[1];
-            if (!key || !value) {
-              return pre;
+          options = resourceQuery.slice(1).split("&").reduce(function(pre, cur) {
+            var _cur_split = _sliced_to_array(cur.split("="), 2), key = _cur_split[0], value = _cur_split[1];
+            if (key && value) {
+              pre[key] = value === "true" ? true : value === "false" ? false : value;
             }
-            pre[key] = value;
             return pre;
           }, {});
-          if (!options.mapFile) {
+          if (!options.loaderId) {
             return [
               2,
               source
@@ -80,8 +77,9 @@ function _loader() {
           ];
         case 4:
           code = generateClient({
-            mapFile: options.mapFile,
-            loaderId: options.loaderId
+            inline: options.inline,
+            action: options.action,
+            routeId: options.routeId
           });
           return [
             2,
@@ -92,3 +90,6 @@ function _loader() {
   });
   return _loader.apply(this, arguments);
 }
+export {
+  loader as default
+};

package/dist/esm/common/constants.js

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

package/dist/esm/runtime/index.js

@@ -3,11 +3,11 @@ import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { installGlobals, writeReadableStreamToWritable, Response as NodeResponse } from "@remix-run/node";
-import { createStaticHandler, ErrorResponse, UNSAFE_DEFERRED_SYMBOL as DEFERRED_SYMBOL } from "@modern-js/utils/runtime/remix-router";
-import { transformNestedRoutes } from "@modern-js/utils/runtime/nested-routes";
+import { createStaticHandler, ErrorResponse, UNSAFE_DEFERRED_SYMBOL as DEFERRED_SYMBOL } from "@modern-js/runtime-utils/remix-router";
+import { transformNestedRoutes } from "@modern-js/runtime-utils/browser";
 import { isPlainObject } from "@modern-js/utils/lodash";
-import { matchEntry, createRequestContext, reporterCtx } from "@modern-js/utils/runtime-node";
-import { time } from "@modern-js/utils/universal/time";
+import { matchEntry, createRequestContext, reporterCtx } from "@modern-js/runtime-utils/node";
+import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 import { CONTENT_TYPE_DEFERRED, LOADER_ID_PARAM } from "../common/constants";
 import { createDeferredReadableStream } from "./response";
@@ -19,10 +19,10 @@ var redirectStatusCodes = /* @__PURE__ */ new Set([
   307,
   308
 ]);
-export function isRedirectResponse(status) {
+function isRedirectResponse(status) {
   return redirectStatusCodes.has(status);
 }
-export function isResponse(value) {
+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) {
@@ -87,7 +87,7 @@ var createLoaderHeaders = function(requestHeaders) {
   }
   return headers;
 };
-var createLoaderRequest = function(context) {
+var createRequest = function(context) {
   var origin = "".concat(context.protocol, "://").concat(context.host);
   var url = new URL(context.url, origin);
   var controller = new AbortController();
@@ -96,7 +96,11 @@ var createLoaderRequest = function(context) {
     headers: createLoaderHeaders(context.headers),
     signal: controller.signal
   };
-  return new Request(url.href, init);
+  if (context.method.toUpperCase() !== "GET" && context.method !== "HEAD") {
+    init.body = context.req;
+  }
+  var request = new Request(url.href, init);
+  return request;
 };
 var sendLoaderResponse = function() {
   var _ref = _async_to_generator(function(res, nodeResponse) {
@@ -155,14 +159,14 @@ var sendLoaderResponse = function() {
     return _ref.apply(this, arguments);
   };
 }();
-export var handleRequest = function() {
+var handleRequest = function() {
   var _ref = _async_to_generator(function(param) {
-    var context, serverRoutes, routesConfig, method, query, routeId, entry, basename, end, res, logger, reporter, routes, queryRoute, request, requestContext, response, deferredData, body, init, headers, error, _logger, message, cost;
+    var context, serverRoutes, routesConfig, query, routeId, entry, basename, end, res, logger, reporter, routes, queryRoute, request, requestContext, response, deferredData, body, init, headers, error, message, cost;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
           context = param.context, serverRoutes = param.serverRoutes, routesConfig = param.routes;
-          method = context.method, query = context.query;
+          query = context.query;
           routeId = query[LOADER_ID_PARAM];
           entry = matchEntry(context.path, serverRoutes);
           if (!routeId || !entry) {
@@ -170,17 +174,14 @@ export var handleRequest = function() {
               2
             ];
           }
-          if (method.toLowerCase() !== "get") {
-            throw new Error("CSR data loader request only support http GET method");
-          }
           basename = entry.urlPath;
           end = time();
           res = context.res, logger = context.logger, reporter = context.reporter;
           routes = transformNestedRoutes(routesConfig, reporter);
           queryRoute = createStaticHandler(routes, {
-            basename: basename
+            basename
           }).queryRoute;
-          request = createLoaderRequest(context);
+          request = createRequest(context);
           requestContext = createRequestContext();
           requestContext.set(reporterCtx, reporter);
           _state.label = 1;
@@ -194,8 +195,8 @@ export var handleRequest = function() {
           return [
             4,
             queryRoute(request, {
-              routeId: routeId,
-              requestContext: requestContext
+              routeId,
+              requestContext
             })
           ];
         case 2:
@@ -231,7 +232,11 @@ export var handleRequest = function() {
         case 3:
           error = _state.sent();
           message = _instanceof(error, ErrorResponse) ? error.data : String(error);
-          (_logger = logger) === null || _logger === void 0 ? void 0 : _logger.error(message);
+          if (_instanceof(error, Error)) {
+            logger === null || logger === void 0 ? void 0 : logger.error(error);
+          } else {
+            logger === null || logger === void 0 ? void 0 : logger.error(message);
+          }
           response = new NodeResponse(message, {
             status: 500,
             headers: {
@@ -261,3 +266,8 @@ export var handleRequest = function() {
     return _ref.apply(this, arguments);
   };
 }();
+export {
+  handleRequest,
+  isRedirectResponse,
+  isResponse
+};

package/dist/esm/runtime/response.js

@@ -3,12 +3,12 @@ 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/utils/runtime-node";
+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:";
-export function createDeferredReadableStream(deferredData, signal) {
+function createDeferredReadableStream(deferredData, signal) {
   var encoder = new TextEncoder();
   var stream = new ReadableStream({
     start: function start(controller) {
@@ -102,3 +102,6 @@ function enqueueTrackedPromise(controller, encoder, settledKey, promise) {
     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/server/index.js

@@ -3,8 +3,8 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import fs from "fs";
 import { MAIN_ENTRY_NAME, SERVER_BUNDLE_DIRECTORY } from "@modern-js/utils";
-import { matchEntry } from "@modern-js/utils/runtime-node";
-export default function() {
+import { matchEntry } from "@modern-js/runtime-utils/node";
+function server_default() {
   return {
     name: "@modern-js/plugin-data-loader",
     setup: function() {
@@ -43,9 +43,9 @@ export default function() {
                     return [
                       2,
                       handleRequest({
-                        serverRoutes: serverRoutes,
-                        context: context,
-                        routes: routes
+                        serverRoutes,
+                        context,
+                        routes
                       })
                     ];
                 }
@@ -61,3 +61,6 @@ export default function() {
   };
 }
 ;
+export {
+  server_default as default
+};