@tanstack/solid-start/dist/esm/solid-rpc-flight-server.js

Modern and scalable routing for Solid applications

import { createSolidStartFlightMatch } from "./solid-rpc-flight.js";
import { createMemoryHistory } from "@tanstack/solid-router";
import { provideRequestEvent } from "@solidjs/web/storage";
import { getStartContext, runWithStartContext } from "@tanstack/start-storage-context";
import { attachRouterServerSsrUtils } from "@tanstack/solid-router/ssr/server";
//#region src/solid-rpc-flight-server.ts
var collectSolidStartFlightData = async (event, outcome) => {
	const href = getTargetHref(outcome);
	if (!href) return;
	const startContext = getStartContext({ throwIfNotFound: false });
	if (!startContext) return;
	const targetUrl = new URL(href);
	const request = new Request(targetUrl, {
		headers: outcome.foldedHeaders,
		signal: outcome.request.signal
	});
	const flightEvent = {
		...event,
		request
	};
	const router = await startContext.getRouter();
	router.update({
		history: createMemoryHistory({ initialEntries: [targetUrl.pathname + targetUrl.search + targetUrl.hash] }),
		origin: targetUrl.origin
	});
	return await provideRequestEvent(flightEvent, async () => {
		return await runWithStartContext({
			...startContext,
			handlerType: "router",
			request
		}, async () => {
			let attachedServerSsr = false;
			try {
				if (router.options.dehydrate && !router.serverSsr) {
					attachRouterServerSsrUtils({
						router,
						manifest: void 0
					});
					attachedServerSsr = true;
				}
				await router.load({ _signal: outcome.request.signal });
				const dehydratedData = await router.options.dehydrate?.();
				router.serverSsr?.setRenderFinished();
				return {
					...dehydratedData === void 0 ? {} : { dehydratedData },
					href: targetUrl.href,
					matches: router.stores.matches.get().map(createSolidStartFlightMatch)
				};
			} catch (error) {
				console.error("Unable to collect TanStack Start flight data", error);
				return;
			} finally {
				if (attachedServerSsr) router.serverSsr?.cleanup();
			}
		});
	});
};
function getTargetHref(outcome) {
	const redirectHref = getTanStackRedirectHref(outcome.value);
	const target = redirectHref ? new URL(redirectHref, outcome.request.headers.get("referer") ?? outcome.request.url) : outcome.targetUrl ? new URL(outcome.targetUrl) : void 0;
	if (!target || target.origin !== new URL(outcome.request.url).origin) return;
	return target.href;
}
function getTanStackRedirectHref(value) {
	if (!isObject(value) || !isObject(value.error)) return;
	const error = value.error;
	if (error.isSerializedRedirect !== true) return;
	if (typeof error.href === "string") return error.href;
	if (isObject(error.headers) && typeof error.headers.location === "string") return error.headers.location;
	return typeof error.to === "string" ? error.to : void 0;
}
function isObject(value) {
	return !!value && typeof value === "object";
}
//#endregion
export { collectSolidStartFlightData };

//# sourceMappingURL=solid-rpc-flight-server.js.map