@modern-js/plugin-data-loader 2.0.0-beta.3 → 2.0.0-beta.6

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

@@ -1,23 +1,60 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = loader;
-var _generateClient = require("./generate-client");
-// eslint-disable-next-line eslint-comments/disable-enable-pair
-/* eslint-disable @babel/no-invalid-this */
-
-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;
-  if (target === 'node') {
-    return source;
+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 });
   }
-  const options = this.getOptions();
-  const code = (0, _generateClient.generateClient)({
-    mapFile: options.mapFile
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+var loader_exports = {};
+__export(loader_exports, {
+  default: () => loader
+});
+module.exports = __toCommonJS(loader_exports);
+var import_generate_client = require("./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 = (0, import_generate_client.generateClient)({
+      mapFile: options.mapFile
+    });
+    return code;
   });
-  return code;
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

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

@@ -1,57 +1,110 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+var server_exports = {};
+__export(server_exports, {
+  default: () => server_default,
+  getPathWithoutEntry: () => getPathWithoutEntry,
+  handleRequest: () => handleRequest,
+  isRedirectResponse: () => isRedirectResponse,
+  isResponse: () => isResponse
 });
-exports.handleRequest = exports.getPathWithoutEntry = exports.default = void 0;
-exports.isRedirectResponse = isRedirectResponse;
-exports.isResponse = isResponse;
-var _node = require("@remix-run/node");
-var _reactRouterDom = require("react-router-dom");
-var _utils = require("@modern-js/utils");
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-// Polyfill Web Fetch API
-(0, _node.installGlobals)();
-const LOADER_SEARCH_PARAM = '_loader';
-const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
+module.exports = __toCommonJS(server_exports);
+var import_path = __toESM(require("path"));
+var import_node = require("@remix-run/node");
+var import_react_router_dom = require("react-router-dom");
+var import_utils = require("@modern-js/utils");
+(0, import_node.installGlobals)();
+const LOADER_SEARCH_PARAM = "_loader";
+const redirectStatusCodes = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
 function isRedirectResponse(response) {
   return redirectStatusCodes.has(response.status);
 }
 function isResponse(value) {
-  return value != null && typeof value.status === 'number' && typeof value.statusText === 'string' && typeof value.headers === 'object' && typeof value.body !== 'undefined';
+  return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
 }
 const json = (data, init = {}) => {
-  const responseInit = typeof init === 'number' ? {
-    status: init
-  } : init;
+  const responseInit = typeof init === "number" ? { status: init } : init;
   const headers = new Headers(responseInit.headers);
-  if (!headers.has('Content-Type')) {
-    headers.set('Content-Type', 'application/json; charset=utf-8');
+  if (!headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json; charset=utf-8");
   }
-  return new _node.Response(JSON.stringify(data), _objectSpread(_objectSpread({}, responseInit), {}, {
+  return new import_node.Response(JSON.stringify(data), __spreadProps(__spreadValues({}, responseInit), {
     headers
   }));
 };
-
-// TODO: 添加 context
-const callRouteLoader = async ({
+const callRouteLoader = (_0) => __async(void 0, [_0], function* ({
   routeId,
   loader,
   params,
   request,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   loadContext
-}) => {
+}) {
   if (!loader) {
-    throw new Error(`You made a ${request.method} request to ${request.url} but did not provide ` + `a default component or \`loader\` for route "${routeId}", ` + `so there is no way to handle the request.`);
+    throw new Error(
+      `You made a ${request.method} request to ${request.url} but did not provide a default component or \`loader\` for route "${routeId}", so there is no way to handle the request.`
+    );
   }
   let result;
   try {
-    result = await loader({
+    result = yield loader({
       request,
       params
     });
@@ -61,12 +114,14 @@ const callRouteLoader = async ({
     }
     result = error;
   }
-  if (result === undefined) {
-    throw new Error(`You defined a loader for route "${routeId}" but didn't return ` + `anything from your \`loader\` function. Please return a value or \`null\`.`);
+  if (result === void 0) {
+    throw new Error(
+      `You defined a loader for route "${routeId}" but didn't return anything from your \`loader\` function. Please return a value or \`null\`.`
+    );
   }
   return isResponse(result) ? result : json(result);
-};
-const createLoaderHeaders = requestHeaders => {
+});
+const createLoaderHeaders = (requestHeaders) => {
   const headers = new Headers();
   for (const [key, values] of Object.entries(requestHeaders)) {
     if (values) {
@@ -81,9 +136,8 @@ const createLoaderHeaders = requestHeaders => {
   }
   return headers;
 };
-const createLoaderRequest = context => {
+const createLoaderRequest = (context) => {
   const origin = `${context.protocol}://${context.host}`;
-  // eslint-disable-next-line node/no-unsupported-features/node-builtins, node/prefer-global/url
   const url = new URL(context.url, origin);
   const controller = new AbortController();
   const init = {
@@ -93,62 +147,59 @@ const createLoaderRequest = context => {
   };
   return new Request(url.href, init);
 };
-const sendLoaderResponse = async (res, nodeResponse) => {
+const sendLoaderResponse = (res, nodeResponse) => __async(void 0, null, function* () {
   res.statusMessage = nodeResponse.statusText;
   res.statusCode = nodeResponse.status;
   for (const [key, value] of nodeResponse.headers.entries()) {
     res.setHeader(key, value);
   }
   if (nodeResponse.body) {
-    await (0, _node.writeReadableStreamToWritable)(nodeResponse.body, res);
+    yield (0, import_node.writeReadableStreamToWritable)(nodeResponse.body, res);
   } else {
     res.end();
   }
-};
+});
 const getPathWithoutEntry = (pathname, entryPath) => {
-  if (entryPath === '/') {
+  if (entryPath === "/") {
     return pathname;
   }
-  return pathname.replace(entryPath, '');
+  return pathname.replace(entryPath, "");
 };
-exports.getPathWithoutEntry = getPathWithoutEntry;
 const matchEntry = (pathname, entries) => {
-  return entries.find(entry => pathname.startsWith(entry.urlPath));
+  return entries.find((entry) => pathname.startsWith(entry.urlPath));
 };
-const handleRequest = async ({
+const handleRequest = (_0) => __async(void 0, [_0], function* ({
   context,
   serverRoutes,
   distDir
-}) => {
-  const {
-    method,
-    query
-  } = context;
+}) {
+  const { method, query } = context;
   const routeId = query[LOADER_SEARCH_PARAM];
-  if (!routeId || method.toLowerCase() !== 'get') {
+  if (!routeId || method.toLowerCase() !== "get") {
     return;
   }
   const entry = matchEntry(context.path, serverRoutes);
   if (!entry) {
     return;
   }
-  const {
-    routes
-  } = await Promise.resolve(`${distDir}/${_utils.LOADER_ROUTES_DIR}/${entry.entryName}`).then(s => _interopRequireWildcard(require(s)));
+  const routesPath = import_path.default.join(
+    distDir,
+    import_utils.LOADER_ROUTES_DIR,
+    entry.entryName || import_utils.MAIN_ENTRY_NAME
+  );
+  const { routes } = yield Promise.resolve().then(() => __toESM(require(routesPath)));
   if (!routes) {
     return;
   }
-  const {
-    res
-  } = context;
+  const { res } = context;
   const pathname = getPathWithoutEntry(context.path, entry.urlPath);
-  const matches = (0, _reactRouterDom.matchRoutes)(routes, pathname);
+  const matches = (0, import_react_router_dom.matchRoutes)(routes, pathname);
   if (!matches) {
     res.statusCode = 403;
     res.end(`Route ${pathname} was not matched`);
     return;
   }
-  const match = matches === null || matches === void 0 ? void 0 : matches.find(match => match.route.id === routeId);
+  const match = matches == null ? void 0 : matches.find((match2) => match2.route.id === routeId);
   if (!match) {
     res.statusCode = 403;
     res.end(`Route ${routeId} does not match URL ${context.path}`);
@@ -157,7 +208,7 @@ const handleRequest = async ({
   const request = createLoaderRequest(context);
   let response;
   try {
-    response = await callRouteLoader({
+    response = yield callRouteLoader({
       loader: match.route.loader,
       routeId: match.route.id,
       params: match.params,
@@ -166,40 +217,45 @@ const handleRequest = async ({
     });
     if (isRedirectResponse(response)) {
       const headers = new Headers(response.headers);
-      headers.set('X-Modernjs-Redirect', headers.get('Location'));
-      headers.delete('Location');
-      response = new _node.Response(null, {
+      headers.set("X-Modernjs-Redirect", headers.get("Location"));
+      headers.delete("Location");
+      response = new import_node.Response(null, {
         status: 204,
         headers
       });
     }
   } catch (error) {
     const message = String(error);
-    response = new _node.Response(message, {
+    response = new import_node.Response(message, {
       status: 500,
       headers: {
-        'Content-Type': 'text/plain'
+        "Content-Type": "text/plain"
       }
     });
   }
   sendLoaderResponse(res, response);
-};
-exports.handleRequest = handleRequest;
-var _default = () => ({
-  name: '@modern-js/plugin-data-loader',
+});
+var server_default = () => ({
+  name: "@modern-js/plugin-data-loader",
   setup: () => ({
     preparebeforeRouteHandler({
       serverRoutes,
       distDir
     }) {
-      return async context => {
+      return (context) => __async(this, null, function* () {
         return handleRequest({
           serverRoutes,
           distDir,
           context
         });
-      };
+      });
     }
   })
 });
-exports.default = _default;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPathWithoutEntry,
+  handleRequest,
+  isRedirectResponse,
+  isResponse
+});

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

@@ -1,70 +1,184 @@
-import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-// eslint-disable-next-line eslint-comments/disable-enable-pair
-/* eslint-disable node/prefer-global/url */
-// eslint-disable-next-line eslint-comments/disable-enable-pair
-/* eslint-disable node/no-unsupported-features/node-builtins */
-import { compile } from 'path-to-regexp';
-import { redirect } from 'react-router-dom';
-export var getRequestUrl = function getRequestUrl(_ref) {
-  var params = _ref.params,
-    request = _ref.request,
-    routeId = _ref.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', routeId);
-  return url;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+var __generator = this && this.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return(g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g);
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
 };
-var handleRedirectResponse = function handleRedirectResponse(res) {
-  var headers = res.headers;
-  var location = headers.get('X-Modernjs-Redirect');
-  if (location) {
-    return redirect(location);
-  }
-  return res;
+import { compile } from "path-to-regexp";
+import { redirect } from "react-router-dom";
+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", routeId);
+    return url;
 };
-export var createRequest = function createRequest(routeId) {
-  var method = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'get';
-  return /*#__PURE__*/function () {
-    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref2) {
-      var params, request, url, res;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              params = _ref2.params, request = _ref2.request;
-              url = getRequestUrl({
-                params: params,
-                request: request,
-                routeId: routeId
-              });
-              _context.prev = 2;
-              _context.next = 5;
-              return fetch(url, {
-                method: method,
-                signal: request.signal
-              });
-            case 5:
-              res = _context.sent;
-              return _context.abrupt("return", handleRedirectResponse(res));
-            case 9:
-              _context.prev = 9;
-              _context.t0 = _context["catch"](2);
-              console.error(_context.t0);
-              throw _context.t0;
-            case 13:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee, null, [[2, 9]]);
-    }));
-    return function (_x) {
-      return _ref3.apply(this, arguments);
-    };
-  }();
-};
+var handleRedirectResponse = function(res) {
+    var headers = res.headers;
+    var location = headers.get("X-Modernjs-Redirect");
+    if (location) {
+        return redirect(location);
+    }
+    return res;
+};
+var createRequest = function(routeId) {
+    var method = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "get";
+    return function() {
+        var _ref = _asyncToGenerator(function(param) {
+            var params, request, url, res;
+            return __generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        params = param.params, request = param.request;
+                        url = getRequestUrl({
+                            params: params,
+                            request: request,
+                            routeId: routeId
+                        });
+                        return [
+                            4,
+                            fetch(url, {
+                                method: method,
+                                signal: request.signal
+                            })
+                        ];
+                    case 1:
+                        res = _state.sent();
+                        if (!res.ok) {
+                            throw res;
+                        }
+                        return [
+                            2,
+                            handleRedirectResponse(res)
+                        ];
+                }
+            });
+        });
+        return function(_) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+};
+export { createRequest, getRequestUrl };