one/dist/cjs/createHandleRequest.native.js

One is a new React Framework that makes Vite serve both native and web.

"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: !0 });
}, __copyProps = (to, from, except, desc) => {
  if (from && typeof from == "object" || typeof from == "function")
    for (let key of __getOwnPropNames(from))
      !__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: !0 }), mod);
var createHandleRequest_exports = {};
__export(createHandleRequest_exports, {
  compileManifest: () => compileManifest,
  createHandleRequest: () => createHandleRequest,
  getURLfromRequestURL: () => getURLfromRequestURL,
  resolveAPIRoute: () => resolveAPIRoute,
  resolveLoaderRoute: () => resolveLoaderRoute,
  resolvePageRoute: () => resolvePageRoute,
  runMiddlewares: () => runMiddlewares
});
module.exports = __toCommonJS(createHandleRequest_exports);
var import_constants = require("./constants"), import_cleanUrl = require("./utils/cleanUrl"), import_isResponse = require("./utils/isResponse"), import_getManifest = require("./vite/getManifest"), import_resolveResponse = require("./vite/resolveResponse");
async function runMiddlewares(handlers, request, route, getResponse) {
  var middlewares = route.middlewares;
  if (!(middlewares != null && middlewares.length))
    return await getResponse();
  if (!handlers.loadMiddleware)
    throw new Error("No middleware handler configured");
  var context = {};
  async function dispatch(index) {
    var _this, middlewareModule = middlewares[index];
    if (!middlewareModule)
      return await getResponse();
    var exported = (_this = await handlers.loadMiddleware(middlewareModule)) === null || _this === void 0 ? void 0 : _this.default;
    if (!exported)
      throw new Error(`No valid export found in middleware: ${middlewareModule.contextKey}`);
    var next = async function() {
      return dispatch(index + 1);
    }, response = await exported({
      request,
      next,
      context
    });
    return response || dispatch(index + 1);
  }
  return dispatch(0);
}
async function resolveAPIRoute(handlers, request, url, route) {
  var { pathname } = url, params = getRouteParams(pathname, route);
  try {
    return (0, import_resolveResponse.resolveAPIEndpoint)(function() {
      return handlers.handleAPI({
        request,
        route,
        url,
        loaderProps: {
          path: pathname,
          params
        }
      });
    }, request, params || {});
  } catch (err) {
    if ((0, import_isResponse.isResponse)(err))
      return err;
    throw process.env.NODE_ENV === "development" && console.error(`
 [one] Error importing API route at ${pathname}:

        ${err}

        If this is an import error, you can likely fix this by adding this dependency to
        the "optimizeDeps.include" array in your vite.config.ts.
      `), err;
  }
}
async function resolveLoaderRoute(handlers, request, url, route) {
  return await runMiddlewares(handlers, request, route, async function() {
    return await (0, import_resolveResponse.resolveResponse)(async function() {
      var headers = new Headers();
      headers.set("Content-Type", "text/javascript");
      try {
        var loaderResponse = await handlers.handleLoader({
          request,
          route,
          url,
          loaderProps: {
            path: url.pathname,
            request: route.type === "ssr" ? request : void 0,
            params: getLoaderParams(url, route)
          }
        });
        return new Response(loaderResponse, {
          headers
        });
      } catch (err) {
        if ((0, import_isResponse.isResponse)(err))
          return err;
        throw console.error(`Error running loader: ${err}`), err;
      }
    });
  });
}
async function resolvePageRoute(handlers, request, url, route) {
  var { pathname, search } = url;
  return (0, import_resolveResponse.resolveResponse)(async function() {
    var resolved = await runMiddlewares(handlers, request, route, async function() {
      return await handlers.handlePage({
        request,
        route,
        url,
        loaderProps: {
          path: pathname + search,
          // Ensure SSR loaders receive the original request
          request: route.type === "ssr" ? request : void 0,
          params: getLoaderParams(url, route)
        }
      });
    });
    return resolved;
  });
}
function getURLfromRequestURL(request) {
  var urlString = request.url || "";
  return new URL(urlString || "", request.headers.get("host") ? `http://${request.headers.get("host")}` : "");
}
function compileRouteRegex(route) {
  return {
    ...route,
    compiledRegex: new RegExp(route.namedRegex)
  };
}
function compileManifest(manifest) {
  return {
    pageRoutes: manifest.pageRoutes.map(compileRouteRegex),
    apiRoutes: manifest.apiRoutes.map(compileRouteRegex)
  };
}
function createHandleRequest(handlers, param) {
  var { routerRoot } = param, manifest = (0, import_getManifest.getManifest)({
    routerRoot
  });
  if (!manifest)
    throw new Error("No routes manifest");
  var compiledManifest = compileManifest(manifest);
  return {
    manifest,
    handler: async function(request) {
      var url = getURLfromRequestURL(request), { pathname, search } = url;
      if (pathname === "/__vxrnhmr" || pathname.startsWith("/@"))
        return null;
      if (handlers.handleAPI) {
        var apiRoute = compiledManifest.apiRoutes.find(function(route2) {
          return route2.compiledRegex.test(pathname);
        });
        if (apiRoute)
          return await resolveAPIRoute(handlers, request, url, apiRoute);
      }
      if (request.method !== "GET")
        return null;
      if (handlers.handleLoader) {
        var isClientRequestingNewRoute = pathname.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED);
        if (isClientRequestingNewRoute) {
          var originalUrl = (0, import_cleanUrl.getPathFromLoaderPath)(pathname), _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
          try {
            for (var _iterator = compiledManifest.pageRoutes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
              var route = _step.value;
              if (route.file !== "") {
                var finalUrl = new URL(originalUrl, url.origin);
                if (finalUrl.search = url.search, !!route.compiledRegex.test(finalUrl.pathname))
                  return resolveLoaderRoute(handlers, request, finalUrl, route);
              }
            }
          } catch (err) {
            _didIteratorError = !0, _iteratorError = err;
          } finally {
            try {
              !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
            } finally {
              if (_didIteratorError)
                throw _iteratorError;
            }
          }
          return process.env.NODE_ENV === "development" && console.error("No matching route found for loader!", {
            originalUrl,
            pathname,
            routes: manifest.pageRoutes
          }), Response.error();
        }
      }
      if (handlers.handlePage) {
        var _iteratorNormalCompletion1 = !0, _didIteratorError1 = !1, _iteratorError1 = void 0;
        try {
          for (var _iterator1 = compiledManifest.pageRoutes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
            var route1 = _step1.value;
            if (route1.compiledRegex.test(pathname))
              return resolvePageRoute(handlers, request, url, route1);
          }
        } catch (err) {
          _didIteratorError1 = !0, _iteratorError1 = err;
        } finally {
          try {
            !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
          } finally {
            if (_didIteratorError1)
              throw _iteratorError1;
          }
        }
      }
      return null;
    }
  };
}
function getLoaderParams(url, config) {
  var params = {}, match = new RegExp(config.compiledRegex).exec(url.pathname);
  if (match != null && match.groups) {
    var _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
    try {
      for (var _iterator = Object.entries(match.groups)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
        var [key, value] = _step.value, namedKey = config.routeKeys[key];
        params[namedKey] = value;
      }
    } catch (err) {
      _didIteratorError = !0, _iteratorError = err;
    } finally {
      try {
        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
      } finally {
        if (_didIteratorError)
          throw _iteratorError;
      }
    }
  }
  return params;
}
function getRouteParams(pathname, route) {
  var regex = new RegExp(route.namedRegex), match = regex.exec(pathname);
  return match ? Object.fromEntries(Object.entries(route.routeKeys).map(function(param) {
    var [key, value] = param, _match_groups;
    return [
      value,
      ((_match_groups = match.groups) === null || _match_groups === void 0 ? void 0 : _match_groups[key]) || ""
    ];
  })) : {};
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  compileManifest,
  createHandleRequest,
  getURLfromRequestURL,
  resolveAPIRoute,
  resolveLoaderRoute,
  resolvePageRoute,
  runMiddlewares
});
//# sourceMappingURL=createHandleRequest.js.map