one/dist/cjs/createDevHandleRequest.cjs

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

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
    });
  }
  return to;
};
var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
  value: true
}), mod);
var createDevHandleRequest_exports = {};
__export(createDevHandleRequest_exports, {
  createHandleRequest: () => createHandleRequest
});
module.exports = __toCommonJS(createDevHandleRequest_exports);
var import_constants = require("./constants.cjs");
var import_createHandleRequest = require("./createHandleRequest.cjs");
var import_cleanUrl = require("./utils/cleanUrl.cjs");
var import_getManifest = require("./vite/getManifest.cjs");
const debugRouter = process.env.ONE_DEBUG_ROUTER;
function createHandleRequest(handlers, {
  routerRoot,
  ignoredRouteFiles,
  routePaths
}) {
  const manifest = (0, import_getManifest.getManifest)({
    routerRoot,
    ignoredRouteFiles,
    routePaths
  });
  if (!manifest) {
    throw new Error(`No routes manifest`);
  }
  const compiledManifest = (0, import_createHandleRequest.compileManifest)(manifest);
  return {
    manifest,
    handler: async function handleRequest(request) {
      const url = (0, import_createHandleRequest.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 = (0, import_createHandleRequest.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 (0, import_createHandleRequest.resolveAPIRoute)(handlers, request, url, apiRoute);
        }
      }
      if (!(0, import_createHandleRequest.isPageRequestMethod)(request.method)) {
        return null;
      }
      if (handlers.handleLoader) {
        const isClientRequestingNewRoute = pathname.endsWith(import_constants.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 = (0, import_cleanUrl.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 (0, import_createHandleRequest.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 (0, import_createHandleRequest.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 (0, import_createHandleRequest.resolvePageRoute)(handlers, request, url, route);
        }
      }
      return null;
    }
  };
}