one/dist/esm/createHandleRequest.mjs

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

import { LOADER_JS_POSTFIX_UNCACHED } from "./constants.mjs";
import { isResponse } from "./utils/isResponse.mjs";
import { resolveAPIEndpoint, resolveResponse } from "./vite/resolveResponse.mjs";
const debugRouter = process.env.ONE_DEBUG_ROUTER;
const staticAssetPathRe = /\.(?:[a-z0-9]{2,4}|webmanifest|wasm|woff2)$/i;
function isStaticAssetRequestPath(pathname) {
  return !pathname.endsWith(LOADER_JS_POSTFIX_UNCACHED) && staticAssetPathRe.test(pathname);
}
function isPageRequestMethod(method) {
  return method === "GET" || method === "HEAD";
}
function ensureResponse(value) {
  if (isResponse(value)) return value;
  if (typeof value === "string") {
    return new Response(value, {
      headers: {
        "Content-Type": "text/html"
      }
    });
  }
  if (value && typeof value === "object") {
    return Response.json(value);
  }
  return new Response(value);
}
async function runMiddlewares(handlers, request, route, getResponse) {
  const middlewares = route.middlewares;
  if (!middlewares?.length) {
    return await getResponse();
  }
  if (!handlers.loadMiddleware) {
    throw new Error(`No middleware handler configured`);
  }
  if (debugRouter) {
    console.info(`[one] \u{1F517} middleware chain (${middlewares.length}) for ${route.page}`);
  }
  const context = {};
  async function dispatch(index) {
    const middlewareModule = middlewares[index];
    if (!middlewareModule) {
      if (debugRouter) {
        console.info(`[one] \u2713 middleware chain complete`);
      }
      return ensureResponse(await getResponse());
    }
    if (debugRouter) {
      console.info(`[one]   \u2192 middleware[${index}]: ${middlewareModule.contextKey}`);
    }
    const exported = (await handlers.loadMiddleware(middlewareModule))?.default;
    if (!exported) {
      throw new Error(`No valid export found in middleware: ${middlewareModule.contextKey}`);
    }
    const next = async () => {
      return dispatch(index + 1);
    };
    const response = await exported({
      request,
      next,
      context
    });
    if (response) {
      if (debugRouter) {
        console.info(`[one]   \u2190 middleware[${index}] returned early (status: ${response.status})`);
      }
      return response;
    }
    return dispatch(index + 1);
  }
  return dispatch(0);
}
async function resolveAPIRoute(handlers, request, url, route, env, executionCtx) {
  const {
    pathname
  } = url;
  const params = getRouteParams(pathname, route);
  if (debugRouter) {
    console.info(`[one] \u{1F4E1} API ${request.method} ${pathname} \u2192 ${route.file}`, params);
  }
  return await runMiddlewares(handlers, request, route, async () => {
    try {
      return resolveAPIEndpoint(() => handlers.handleAPI({
        request,
        route,
        url,
        loaderProps: {
          path: pathname,
          search: url.search,
          subdomain: getSubdomain(url),
          params
        }
      }), request, params || {}, env, executionCtx);
    } catch (err) {
      if (isResponse(err)) {
        return err;
      }
      if (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.
        `);
      }
      throw err;
    }
  });
}
async function resolveLoaderRoute(handlers, request, url, route) {
  if (debugRouter) {
    console.info(`[one] \u{1F4E6} loader ${url.pathname} \u2192 ${route.file}`);
  }
  const isNativeRequest = url.searchParams.get("platform") === "ios" || url.searchParams.get("platform") === "android";
  const response = await runMiddlewares(handlers, request, route, async () => {
    return await resolveResponse(async () => {
      const headers = new Headers();
      headers.set("Content-Type", "text/javascript");
      try {
        const loaderResponse = await handlers.handleLoader({
          request,
          route,
          url,
          loaderProps: {
            path: url.pathname,
            search: url.search,
            subdomain: getSubdomain(url),
            request: route.type === "ssr" ? request : void 0,
            params: getLoaderParams(url, route)
          }
        });
        const body = isNativeRequest && loaderResponse ? toCjsLoader(loaderResponse) : loaderResponse;
        return new Response(body, {
          headers
        });
      } catch (err) {
        if (isResponse(err)) {
          return err;
        }
        if (err?.code !== "ERR_MODULE_NOT_FOUND") {
          console.error(`Error running loader: ${err}`);
        }
        throw err;
      }
    });
  });
  if (response.status >= 300 && response.status < 400) {
    const location = response.headers.get("location");
    if (location) {
      const redirectUrl = new URL(location, url.origin);
      const redirectPath = redirectUrl.pathname + redirectUrl.search + redirectUrl.hash;
      const data = `{__oneRedirect:${JSON.stringify(redirectPath)},__oneRedirectStatus:${response.status}}`;
      const body = isNativeRequest ? `exports.loader=function(){return ${data}}` : `export function loader(){return${data}}`;
      return new Response(body, {
        headers: {
          "Content-Type": "text/javascript"
        }
      });
    }
  }
  if (response.status === 401 || response.status === 403) {
    const data = `{__oneError:${response.status},__oneErrorMessage:${JSON.stringify(response.statusText || "Unauthorized")}}`;
    const body = isNativeRequest ? `exports.loader=function(){return ${data}}` : `export function loader(){return${data}}`;
    return new Response(body, {
      headers: {
        "Content-Type": "text/javascript"
      }
    });
  }
  return response;
}
function toCjsLoader(esmCode) {
  if (esmCode.startsWith("exports.")) {
    return esmCode;
  }
  const match = esmCode.match(/export\s+function\s+loader\s*\(\)\s*\{\s*return\s+([\s\S]+)\s*\}/);
  if (match) {
    return `exports.loader=function(){return ${match[1]}}`;
  }
  return `exports.loader=function(){return {}}`;
}
async function resolvePageRoute(handlers, request, url, route) {
  const {
    pathname,
    search
  } = url;
  if (debugRouter) {
    console.info(`[one] \u{1F4C4} page ${pathname} \u2192 ${route.file} (${route.type})`);
  }
  const loaderProps = {
    path: pathname,
    search,
    subdomain: getSubdomain(url),
    request: route.type === "ssr" ? request : void 0,
    params: getLoaderParams(url, route)
  };
  if (!route.middlewares?.length) {
    return resolveResponse(() => {
      return handlers.handlePage({
        request,
        route,
        url,
        loaderProps
      });
    });
  }
  return resolveResponse(async () => {
    return await runMiddlewares(handlers, request, route, async () => {
      return await handlers.handlePage({
        request,
        route,
        url,
        loaderProps
      });
    });
  });
}
const _urlCache = /* @__PURE__ */new WeakMap();
function getURLfromRequestURL(request) {
  let url = _urlCache.get(request);
  if (url) return url;
  const urlString = request.url || "";
  const host = request.headers.get("host");
  url = new URL(urlString || "", host ? `http://${host}` : void 0);
  _urlCache.set(request, url);
  return url;
}
function getSubdomain(url) {
  const host = url.hostname;
  if (!host || host === "localhost" || /^\d+\.\d+\.\d+\.\d+$/.test(host)) {
    return void 0;
  }
  const parts = host.split(".");
  if (parts.length < 3) {
    return void 0;
  }
  return parts.slice(0, -2).join(".");
}
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 getLoaderParams(url, config) {
  const params = {};
  const match = config.compiledRegex.exec(url.pathname);
  if (match?.groups) {
    for (const [key, value] of Object.entries(match.groups)) {
      const namedKey = config.routeKeys[key];
      params[namedKey] = value;
    }
  }
  return params;
}
function getRouteParams(pathname, route) {
  const regex = new RegExp(route.namedRegex);
  const match = regex.exec(pathname);
  if (!match) return {};
  return Object.fromEntries(Object.entries(route.routeKeys).map(([key, value]) => {
    return [value, match.groups?.[key] || ""];
  }));
}
export { compileManifest, getLoaderParams, getSubdomain, getURLfromRequestURL, isPageRequestMethod, isStaticAssetRequestPath, resolveAPIRoute, resolveLoaderRoute, resolvePageRoute, runMiddlewares };
//# sourceMappingURL=createHandleRequest.mjs.map