one
Version:
One is a new React Framework that makes Vite serve both native and web.
411 lines (409 loc) • 14.3 kB
JavaScript
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 createHandleRequest_exports = {};
__export(createHandleRequest_exports, {
compileManifest: () => compileManifest,
createHandleRequest: () => createHandleRequest,
getLoaderParams: () => getLoaderParams,
getSubdomain: () => getSubdomain,
getURLfromRequestURL: () => getURLfromRequestURL,
resolveAPIRoute: () => resolveAPIRoute,
resolveLoaderRoute: () => resolveLoaderRoute,
resolvePageRoute: () => resolvePageRoute,
runMiddlewares: () => runMiddlewares
});
module.exports = __toCommonJS(createHandleRequest_exports);
var import_constants = require("./constants.cjs");
var import_cleanUrl = require("./utils/cleanUrl.cjs");
var import_isResponse = require("./utils/isResponse.cjs");
var import_getManifest = require("./vite/getManifest.cjs");
var import_resolveResponse = require("./vite/resolveResponse.cjs");
const debugRouter = process.env.ONE_DEBUG_ROUTER;
function ensureResponse(value) {
if ((0, import_isResponse.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) {
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 (0, import_resolveResponse.resolveAPIEndpoint)(() => handlers.handleAPI({
request,
route,
url,
loaderProps: {
path: pathname,
search: url.search,
subdomain: getSubdomain(url),
params
}
}), request, params || {});
} catch (err) {
if ((0, import_isResponse.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 (0, import_resolveResponse.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 ((0, import_isResponse.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 (0, import_resolveResponse.resolveResponse)(() => {
return handlers.handlePage({
request,
route,
url,
loaderProps
});
});
}
return (0, import_resolveResponse.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 || "";
url = new URL(urlString || "", request.headers.get("host") ? `http://${request.headers.get("host")}` : "");
_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 createHandleRequest(handlers, {
routerRoot,
ignoredRouteFiles
}) {
const manifest = (0, import_getManifest.getManifest)({
routerRoot,
ignoredRouteFiles
});
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,
search
} = 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 = !pathname.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED) && /\.[a-zA-Z0-9]{2,4}$/.test(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 (request.method !== "GET") {
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 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 && isDynamicRoute && !isNotFoundRoute) {
if (debugRouter) {
console.info(`[one] \u26A1 ${pathname} \u2192 skipping dynamic route ${route.page} for static-looking path`);
}
continue;
}
if (looksLikeStaticFile && route.file === "") {
if (debugRouter) {
console.info(`[one] \u26A1 ${pathname} \u2192 404 for probe path (no +not-found defined)`);
}
return new Response(null, {
status: 404,
headers: {
"Content-Type": "text/plain"
}
});
}
if (debugRouter) {
console.info(`[one] \u26A1 ${pathname} \u2192 matched page route: ${route.page} (${route.type})`);
}
return resolvePageRoute(handlers, request, url, route);
}
}
return null;
}
};
}
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] || ""];
}));
}