one/dist/esm/createDevHandleRequest.mjs

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

import { LOADER_JS_POSTFIX_UNCACHED } from "./constants.mjs";
import { compileManifest, getURLfromRequestURL, isPageRequestMethod, isStaticAssetRequestPath, resolveAPIRoute, resolveLoaderRoute, resolvePageRoute, runMiddlewares } from "./createHandleRequest.mjs";
import { getPathFromLoaderPath } from "./utils/cleanUrl.mjs";
import { getManifest } from "./vite/getManifest.mjs";
const debugRouter = process.env.ONE_DEBUG_ROUTER;
function createHandleRequest(handlers, {
  routerRoot,
  ignoredRouteFiles,
  routePaths
}) {
  const manifest = getManifest({
    routerRoot,
    ignoredRouteFiles,
    routePaths
  });
  if (!manifest) {
    throw new Error(`No routes manifest`);
  }
  const compiledManifest = compileManifest(manifest);
  return {
    manifest,
    handler: async function handleRequest(request) {
      const url = getURLfromRequestURL(request);
      const {
        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;
      }
      const looksLikeStaticFile = isStaticAssetRequestPath(pathname);
      if (handlers.handleAPI) {
        const apiRoute = compiledManifest.apiRoutes.find(route => {
          return route.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) {
        const isClientRequestingNewRoute = pathname.endsWith(LOADER_JS_POSTFIX_UNCACHED);
        if (isClientRequestingNewRoute) {
          const platformParam = url.searchParams.get("platform");
          const isNativePlatform = platformParam === "ios" || platformParam === "android" || platformParam === "native";
          if (isNativePlatform && handlers.handleStaticFile) {
            const nativeLoaderPath = pathname.replace(/\.js$/, ".native.js");
            const staticResponse = await handlers.handleStaticFile(nativeLoaderPath);
            if (staticResponse) {
              return staticResponse;
            }
          }
          const originalUrl = getPathFromLoaderPath(pathname);
          for (const route of compiledManifest.pageRoutes) {
            if (route.file === "") {
              continue;
            }
            const finalUrl = new URL(originalUrl, url.origin);
            finalUrl.search = url.search;
            if (!route.compiledRegex.test(finalUrl.pathname)) {
              continue;
            }
            if (route.hasLoader === false) {
              const emptyBody2 = isNativePlatform ? "exports.loader=function(){return undefined}" : "export function loader() { return undefined }";
              return new Response(emptyBody2, {
                headers: {
                  "Content-Type": "text/javascript"
                }
              });
            }
            const cleanedRequest = new Request(finalUrl, request);
            return resolveLoaderRoute(handlers, cleanedRequest, finalUrl, route);
          }
          const emptyBody = isNativePlatform ? "exports.loader=function(){return{}}" : "export {}";
          return new Response(emptyBody, {
            headers: {
              "Content-Type": "text/javascript"
            }
          });
        }
      }
      if (handlers.handlePage) {
        for (const route of compiledManifest.pageRoutes) {
          if (!route.compiledRegex.test(pathname)) {
            continue;
          }
          const isDynamicRoute = Object.keys(route.routeKeys).length > 0;
          const isNotFoundRoute = route.page.endsWith("/+not-found");
          if (looksLikeStaticFile && isNotFoundRoute) {
            if (debugRouter) {
              console.info(`[one] \u26A1 ${pathname} \u2192 bare 404 for static probe on ${route.page}`);
            }
            if (!route.middlewares?.length) {
              return null;
            }
            return await runMiddlewares(handlers, request, route, async () => {
              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 ${route.page} for static asset`);
            }
            continue;
          }
          if (debugRouter) {
            console.info(`[one] \u26A1 ${pathname} \u2192 matched page route: ${route.page} (${route.type})`);
          }
          return resolvePageRoute(handlers, request, url, route);
        }
      }
      return null;
    }
  };
}
export { createHandleRequest };
//# sourceMappingURL=createDevHandleRequest.mjs.map