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

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

@@ -1,8 +1,8 @@
 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 const getRequestUrl = ({ params, request, routeId }) => {
+const getRequestUrl = ({ params, request, routeId }) => {
   const url = new URL(request.url);
   const toPath = compile(url.pathname, {
     encode: encodeURIComponent
@@ -28,7 +28,7 @@ const handleDeferredResponse = async (res) => {
   }
   return res;
 };
-export const createRequest = (routeId, method = "get") => {
+const createRequest = (routeId, method = "get") => {
   return async ({ params, request }) => {
     const url = getRequestUrl({
       params,
@@ -48,3 +48,44 @@ export const createRequest = (routeId, method = "get") => {
     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,6 +1,6 @@
-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";
 const DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
-export async function parseDeferredReadableStream(stream) {
+async function parseDeferredReadableStream(stream) {
   if (!stream) {
     throw new Error("parseDeferredReadableStream requires stream argument");
   }
@@ -135,3 +135,6 @@ function mergeArrays(...arrays) {
   }
   return out;
 }
+export {
+  parseDeferredReadableStream
+};

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

@@ -1,36 +1,32 @@
 import path from "path";
-export const generateClient = ({ mapFile, loaderId }) => {
-  delete require.cache[mapFile];
-  const loadersMap = require(mapFile);
+const generateClient = ({ inline, action, routeId }) => {
   let requestCode = ``;
-  let exportsCode = ``;
   const requestCreatorPath = path.join(__dirname, "./createRequest").replace("/cjs/cli/", "/esm/cli/").replace(/\\/g, "/");
   const importCode = `
-    import { createRequest } from '${requestCreatorPath}';
+    import { createRequest, createActionRequest } from '${requestCreatorPath}';
   `;
-  if (!loaderId) {
-    requestCode = Object.keys(loadersMap).map((loaderId2) => {
-      const { routeId } = loadersMap[loaderId2];
-      return `
-      const ${loaderId2} = createRequest('${routeId}');
+  if (inline) {
+    if (action) {
+      requestCode = `
+      export const loader = createRequest('${routeId}');
+      export const action = createActionRequest('${routeId}')
+    `;
+    } else {
+      requestCode = `
+      export const loader = createRequest('${routeId}');
     `;
-    }).join("");
-    exportsCode = `export {`;
-    for (const loader of Object.keys(loadersMap)) {
-      exportsCode += `${loader},`;
     }
-    exportsCode += "}";
   } else {
-    const loader = loadersMap[loaderId];
     requestCode = `
-      const loader = createRequest('${loader.routeId}');
-    `;
-    exportsCode = `export default loader;`;
+    export default createRequest('${routeId}');
+  `;
   }
   const generatedCode = `
     ${importCode}
     ${requestCode}
-    ${exportsCode}
   `;
   return generatedCode;
 };
+export {
+  generateClient
+};

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

@@ -1,7 +1,7 @@
 import { promisify } from "util";
 import { logger } from "@modern-js/utils/logger";
 import { generateClient } from "./generateClient";
-export default async function loader(source) {
+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;
@@ -12,17 +12,14 @@ export default async function loader(source) {
     return source;
   }
   const { resourceQuery } = this;
-  const options = resourceQuery.slice(1).split("&").map((item) => {
-    return item.split("=");
-  }).reduce((pre, cur) => {
-    const [key, value] = cur;
-    if (!key || !value) {
-      return pre;
+  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;
     }
-    pre[key] = value;
     return pre;
   }, {});
-  if (!options.mapFile) {
+  if (!options.loaderId) {
     return source;
   }
   if (options.clientData) {
@@ -38,8 +35,12 @@ export default async function loader(source) {
     }
   }
   const code = generateClient({
-    mapFile: options.mapFile,
-    loaderId: options.loaderId
+    inline: options.inline,
+    action: options.action,
+    routeId: options.routeId
   });
   return code;
 }
+export {
+  loader as default
+};

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

@@ -1,3 +1,8 @@
-export const LOADER_ID_PARAM = "__loader";
-export const DIRECT_PARAM = "__ssrDirect";
-export const CONTENT_TYPE_DEFERRED = "text/modernjs-deferred";
+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/index.js

@@ -1,9 +1,9 @@
 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";
@@ -15,10 +15,10 @@ const 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) {
@@ -49,7 +49,7 @@ const createLoaderHeaders = (requestHeaders) => {
   }
   return headers;
 };
-const createLoaderRequest = (context) => {
+const createRequest = (context) => {
   const origin = `${context.protocol}://${context.host}`;
   const url = new URL(context.url, origin);
   const controller = new AbortController();
@@ -58,7 +58,11 @@ const createLoaderRequest = (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;
+  }
+  const request = new Request(url.href, init);
+  return request;
 };
 const sendLoaderResponse = async (res, nodeResponse) => {
   res.statusMessage = nodeResponse.statusText;
@@ -72,16 +76,13 @@ const sendLoaderResponse = async (res, nodeResponse) => {
     res.end();
   }
 };
-export const handleRequest = async ({ context, serverRoutes, routes: routesConfig }) => {
-  const { method, query } = context;
+const handleRequest = async ({ context, serverRoutes, routes: routesConfig }) => {
+  const { query } = context;
   const routeId = query[LOADER_ID_PARAM];
   const entry = matchEntry(context.path, serverRoutes);
   if (!routeId || !entry) {
     return;
   }
-  if (method.toLowerCase() !== "get") {
-    throw new Error("CSR data loader request only support http GET method");
-  }
   const basename = entry.urlPath;
   const end = time();
   const { res, logger, reporter } = context;
@@ -89,7 +90,7 @@ export const handleRequest = async ({ context, serverRoutes, routes: routesConfi
   const { queryRoute } = createStaticHandler(routes, {
     basename
   });
-  const request = createLoaderRequest(context);
+  const request = createRequest(context);
   const requestContext = createRequestContext();
   requestContext.set(reporterCtx, reporter);
   let response;
@@ -123,9 +124,12 @@ export const handleRequest = async ({ context, serverRoutes, routes: routesConfi
       });
     }
   } catch (error) {
-    var _logger;
     const message = error instanceof ErrorResponse ? error.data : String(error);
-    (_logger = logger) === null || _logger === void 0 ? void 0 : _logger.error(message);
+    if (error instanceof 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: {
@@ -137,3 +141,8 @@ export const handleRequest = async ({ context, serverRoutes, routes: routesConfi
   reporter.reportTiming(`${LOADER_REPORTER_NAME}-navigation`, cost);
   await sendLoaderResponse(res, response);
 };
+export {
+  handleRequest,
+  isRedirectResponse,
+  isResponse
+};

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

@@ -1,10 +1,10 @@
 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;
 }
 const DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
-export function createDeferredReadableStream(deferredData, signal) {
+function createDeferredReadableStream(deferredData, signal) {
   const encoder = new TextEncoder();
   const stream = new ReadableStream({
     async start(controller) {
@@ -58,3 +58,6 @@ function enqueueTrackedPromise(controller, encoder, settledKey, promise) {
 `));
   }
 }
+export {
+  createDeferredReadableStream
+};

package/dist/esm-node/server/index.js

@@ -1,8 +1,8 @@
 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 () => ({
+import { matchEntry } from "@modern-js/runtime-utils/node";
+var server_default = () => ({
   name: "@modern-js/plugin-data-loader",
   setup: () => ({
     prepareLoaderHandler({ serverRoutes, distDir }) {
@@ -28,3 +28,6 @@ export default () => ({
     }
   })
 });
+export {
+  server_default as default
+};

package/dist/js/modern/cli/create-request.js

@@ -0,0 +1,66 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { compile } from "path-to-regexp";
+import { redirect } from "react-router-dom";
+import { LOADER_ID_PARAM, DIRECT_PARAM } from "../common/constants";
+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) {
+    return redirect(location);
+  }
+  return res;
+};
+const createRequest = (routeId, method = "get") => {
+  return (_0) => __async(void 0, [_0], function* ({
+    params,
+    request
+  }) {
+    const url = getRequestUrl({ params, request, routeId });
+    const res = yield fetch(url, {
+      method,
+      signal: request.signal
+    });
+    if (!res.ok) {
+      throw res;
+    }
+    return handleRedirectResponse(res);
+  });
+};
+export {
+  createRequest,
+  getRequestUrl
+};

package/dist/js/modern/cli/generate-client.js

@@ -0,0 +1,42 @@
+import path from "path";
+const generateClient = ({
+  mapFile,
+  loaderId
+}) => {
+  delete require.cache[mapFile];
+  const loadersMap = require(mapFile);
+  let requestCode = ``;
+  let exportsCode = ``;
+  const requestCreatorPath = path.join(__dirname, "./create-request").replace("/node/cli/", "/treeshaking/cli/").replace(/\\/g, "/");
+  const importCode = `
+    import { createRequest } from '${requestCreatorPath}';
+  `;
+  if (!loaderId) {
+    requestCode = Object.keys(loadersMap).map((loaderId2) => {
+      const { routeId } = loadersMap[loaderId2];
+      return `
+      const ${loaderId2} = createRequest('${routeId}');
+    `;
+    }).join("");
+    exportsCode = `export {`;
+    for (const loader of Object.keys(loadersMap)) {
+      exportsCode += `${loader},`;
+    }
+    exportsCode += "}";
+  } else {
+    const loader = loadersMap[loaderId];
+    requestCode = `
+      const loader = createRequest('${loader.routeId}');
+    `;
+    exportsCode = `export default loader;`;
+  }
+  const generatedCode = `
+    ${importCode}
+    ${requestCode}
+    ${exportsCode}
+  `;
+  return generatedCode;
+};
+export {
+  generateClient
+};

package/dist/js/modern/cli/loader.js

@@ -0,0 +1,40 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { generateClient } from "./generate-client";
+function loader(source) {
+  return __async(this, null, function* () {
+    var _a;
+    this.cacheable();
+    const target = (_a = this._compiler) == null ? void 0 : _a.options.target;
+    if (target === "node") {
+      return source;
+    }
+    const options = this.getOptions();
+    const code = generateClient({
+      mapFile: options.mapFile,
+      loaderId: options.loaderId
+    });
+    return code;
+  });
+}
+export {
+  loader as default
+};

package/dist/js/modern/common/constants.js

@@ -0,0 +1,6 @@
+const LOADER_ID_PARAM = "__loader";
+const DIRECT_PARAM = "__ssrDirect";
+export {
+  DIRECT_PARAM,
+  LOADER_ID_PARAM
+};