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.native.js"),
  import_cleanUrl = require("./utils/cleanUrl.native.js"),
  import_isResponse = require("./utils/isResponse.native.js"),
  import_getManifest = require("./vite/getManifest.native.js"),
  import_resolveResponse = require("./vite/resolveResponse.native.js"),
  debugRouter = process.env.ONE_DEBUG_ROUTER;
async function runMiddlewares(handlers, request, route, getResponse) {
  var middlewares = route.middlewares;
  if (!middlewares?.length) return await getResponse();
  if (!handlers.loadMiddleware) throw new Error("No middleware handler configured");
  debugRouter && console.info(`[one] \u{1F517} middleware chain (${middlewares.length}) for ${route.page}`);
  var context = {};
  async function dispatch(index) {
    var _this,
      middlewareModule = middlewares[index];
    if (!middlewareModule) return debugRouter && console.info("[one] \u2713 middleware chain complete"), await getResponse();
    debugRouter && console.info(`[one]   \u2192 middleware[${index}]: ${middlewareModule.contextKey}`);
    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 ? (debugRouter && console.info(`[one]   \u2190 middleware[${index}] returned early (status: ${response.status})`), response) : dispatch(index + 1);
  }
  return dispatch(0);
}
async function resolveAPIRoute(handlers, request, url, route) {
  var {
      pathname
    } = url,
    params = getRouteParams(pathname, route);
  return debugRouter && console.info(`[one] \u{1F4E1} API ${request.method} ${pathname} \u2192 ${route.file}`, params), await runMiddlewares(handlers, request, route, async function () {
    try {
      return (0, import_resolveResponse.resolveAPIEndpoint)(function () {
        return handlers.handleAPI({
          request,
          route,
          url,
          loaderProps: {
            path: pathname,
            search: url.search,
            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 debugRouter && console.info(`[one] \u{1F4E6} loader ${url.pathname} \u2192 ${route.file}`), 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,
            search: url.search,
            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 debugRouter && console.info(`[one] \u{1F4C4} page ${pathname} \u2192 ${route.file} (${route.type})`), (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 debugRouter && console.info(`[one] \u26A1 ${pathname} \u2192 matched API route: ${apiRoute.page}`), 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)) {
                  var cleanedRequest = new Request(finalUrl, request);
                  return resolveLoaderRoute(handlers, cleanedRequest, 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 debugRouter && console.info(`[one] \u26A1 ${pathname} \u2192 matched page route: ${route1.page} (${route1.type})`), 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?.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]) || ""];
  })) : {};
}
//# sourceMappingURL=createHandleRequest.native.js.map