one/dist/esm/createDevHandleRequest.native.js

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

import { LOADER_JS_POSTFIX_UNCACHED } from "./constants.native.js";
import { compileManifest, getURLfromRequestURL, isPageRequestMethod, isStaticAssetRequestPath, resolveAPIRoute, resolveLoaderRoute, resolvePageRoute, runMiddlewares } from "./createHandleRequest.native.js";
import { getPathFromLoaderPath } from "./utils/cleanUrl.native.js";
import { getManifest } from "./vite/getManifest.native.js";
var debugRouter = process.env.ONE_DEBUG_ROUTER;
function createHandleRequest(handlers, param) {
  var {
    routerRoot,
    ignoredRouteFiles,
    routePaths
  } = param;
  var manifest = getManifest({
    routerRoot,
    ignoredRouteFiles,
    routePaths
  });
  if (!manifest) {
    throw new Error(`No routes manifest`);
  }
  var compiledManifest = compileManifest(manifest);
  return {
    manifest,
    handler: async function handleRequest(request) {
      var url = getURLfromRequestURL(request);
      var {
        pathname
      } = url;
      if (pathname === "/__vxrnhmr" || pathname.startsWith("/@vite/") || pathname.startsWith("/@fs/") || pathname.startsWith("/@id/") || pathname.startsWith("/node_modules/") || pathname.startsWith("/debugger-frontend") || pathname.startsWith("/inspector")) {
        return null;
      }
      var looksLikeStaticFile = isStaticAssetRequestPath(pathname);
      if (handlers.handleAPI) {
        var apiRoute = compiledManifest.apiRoutes.find(function (route2) {
          return route2.compiledRegex.test(pathname);
        });
        if (apiRoute) {
          if (debugRouter) {
            console.info(`[one] \u26A1 ${pathname} \u2192 matched API route: ${apiRoute.page}`);
          }
          return await resolveAPIRoute(handlers, request, url, apiRoute);
        }
      }
      if (!isPageRequestMethod(request.method)) {
        return null;
      }
      if (handlers.handleLoader) {
        var isClientRequestingNewRoute = pathname.endsWith(LOADER_JS_POSTFIX_UNCACHED);
        if (isClientRequestingNewRoute) {
          var platformParam = url.searchParams.get("platform");
          var isNativePlatform = platformParam === "ios" || platformParam === "android" || platformParam === "native";
          if (isNativePlatform && handlers.handleStaticFile) {
            var nativeLoaderPath = pathname.replace(/\.js$/, ".native.js");
            var staticResponse = await handlers.handleStaticFile(nativeLoaderPath);
            if (staticResponse) {
              return staticResponse;
            }
          }
          var originalUrl = getPathFromLoaderPath(pathname);
          var _iteratorNormalCompletion = true,
            _didIteratorError = false,
            _iteratorError = void 0;
          try {
            for (var _iterator = compiledManifest.pageRoutes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
              var route = _step.value;
              if (route.file === "") {
                continue;
              }
              var finalUrl = new URL(originalUrl, url.origin);
              finalUrl.search = url.search;
              if (!route.compiledRegex.test(finalUrl.pathname)) {
                continue;
              }
              if (route.hasLoader === false) {
                var emptyBody = isNativePlatform ? "exports.loader=function(){return undefined}" : "export function loader() { return undefined }";
                return new Response(emptyBody, {
                  headers: {
                    "Content-Type": "text/javascript"
                  }
                });
              }
              var cleanedRequest = new Request(finalUrl, request);
              return resolveLoaderRoute(handlers, cleanedRequest, finalUrl, route);
            }
          } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion && _iterator.return != null) {
                _iterator.return();
              }
            } finally {
              if (_didIteratorError) {
                throw _iteratorError;
              }
            }
          }
          var emptyBody1 = isNativePlatform ? "exports.loader=function(){return{}}" : "export {}";
          return new Response(emptyBody1, {
            headers: {
              "Content-Type": "text/javascript"
            }
          });
        }
      }
      if (handlers.handlePage) {
        var _iteratorNormalCompletion1 = true,
          _didIteratorError1 = false,
          _iteratorError1 = void 0;
        try {
          for (var _iterator1 = compiledManifest.pageRoutes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
            var route1 = _step1.value;
            if (!route1.compiledRegex.test(pathname)) {
              continue;
            }
            var isDynamicRoute = Object.keys(route1.routeKeys).length > 0;
            var isNotFoundRoute = route1.page.endsWith("/+not-found");
            if (looksLikeStaticFile && isNotFoundRoute) {
              var _route_middlewares;
              if (debugRouter) {
                console.info(`[one] \u26A1 ${pathname} \u2192 bare 404 for static probe on ${route1.page}`);
              }
              if (!((_route_middlewares = route1.middlewares) === null || _route_middlewares === void 0 ? void 0 : _route_middlewares.length)) {
                return null;
              }
              return await runMiddlewares(handlers, request, route1, async function () {
                return new Response(null, {
                  status: 404,
                  headers: {
                    "Content-Type": "text/plain"
                  }
                });
              });
            }
            if (looksLikeStaticFile && isDynamicRoute) {
              if (debugRouter) {
                console.info(`[one] \u26A1 ${pathname} \u2192 skipping dynamic route ${route1.page} for static asset`);
              }
              continue;
            }
            if (debugRouter) {
              console.info(`[one] \u26A1 ${pathname} \u2192 matched page route: ${route1.page} (${route1.type})`);
            }
            return resolvePageRoute(handlers, request, url, route1);
          }
        } catch (err) {
          _didIteratorError1 = true;
          _iteratorError1 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
              _iterator1.return();
            }
          } finally {
            if (_didIteratorError1) {
              throw _iteratorError1;
            }
          }
        }
      }
      return null;
    }
  };
}
export { createHandleRequest };
//# sourceMappingURL=createDevHandleRequest.native.js.map