one/dist/esm/createApp.mjs

One is a React framework for web, iOS, and Android apps.

import "./setup.mjs";
import { cloneElement } from "react";
import { resolveClientLoader } from "./clientLoaderResolver.mjs";
import { Root } from "./Root.mjs";
import { render } from "./render.mjs";
import { initClientMatches } from "./router/router.mjs";
import { registerPreloadedRoute } from "./router/useViteRoutes.mjs";
import { setupSkewProtection } from "./skewProtection.mjs";
import { handleSkewError, isChunkLoadError } from "./utils/dynamicImport.mjs";
import { findRootLayout } from "./utils/findRootLayout.mjs";
import { getServerHeadInsertions } from "./useServerHeadInsertion.mjs";
import { SERVER_CONTEXT_POST_RENDER_STRING } from "./vite/constants.mjs";
import { safeJsonStringify } from "./utils/htmlEscape.mjs";
import { getServerContext, setServerContext } from "./vite/one-server-only.mjs";
import { Fragment, jsx } from "react/jsx-runtime";

function createApp(options) {
	if (import.meta.env.SSR) {
		let cachedServerRender;
		let cachedRenderToStaticMarkup;
		let cachedRenderToString;
		let setupDone = false;
		return {
			options,
			render: async (props) => {
				const renderMode = props.mode === "spa-shell" ? "spa" : props.mode;
				const shouldRunSetup = props.mode !== "ssg" && props.mode !== "spa-shell";
				if (process.env.ONE_RENDER_MODE !== renderMode) {
					process.env.ONE_RENDER_MODE = renderMode;
				}
				if (shouldRunSetup && !setupDone && options.getSetupPromise) {
					await options.getSetupPromise();
					setupDone = true;
				}
				if (!cachedServerRender) {
					const sr = await import("./server-render.mjs");
					cachedServerRender = sr;
					cachedRenderToStaticMarkup = sr.renderToStaticMarkup;
					cachedRenderToString = sr.renderToString;
				}
				const renderToStaticMarkup = cachedRenderToStaticMarkup;
				const renderToString = cachedRenderToString;
				const { loaderData, loaderProps, css, cssContents, mode, loaderServerData, routePreloads: routePreloads2, matches } = props;
				setServerContext({
					postRenderData: loaderServerData,
					loaderData,
					loaderProps,
					mode,
					css,
					cssContents,
					routePreloads: routePreloads2,
					matches
				});
				let renderId;
				const rootElement = /* @__PURE__ */ jsx(Root, {
					flags: options.flags,
					onRenderId: (id) => {
						renderId = id;
					},
					routes: options.routes,
					routerRoot: options.routerRoot,
					linking: options.linking,
					...props
				});
				let html = await renderToString(rootElement, { preloads: props.preloads });
				if (renderId) {
					const insertions = getServerHeadInsertions(renderId);
					if (insertions?.length) {
						const extraHeadElements = insertions.map((insertion) => insertion()).filter(Boolean);
						if (extraHeadElements.length) {
							const extraHeadHTML = renderToStaticMarkup(/* @__PURE__ */ jsx(Fragment, { children: extraHeadElements.map((x, i) => cloneElement(x, { key: i })) }));
							if (extraHeadHTML) {
								html = html.replace(`</head>`, `${extraHeadHTML}</head>`);
							}
						}
					}
				}
				const postRenderData = getServerContext()?.postRenderData;
				if (postRenderData) {
					html = html.replace(safeJsonStringify(SERVER_CONTEXT_POST_RENDER_STRING), safeJsonStringify(postRenderData));
				}
				return html;
			},
			renderStream: async (props) => {
				const renderMode = props.mode === "spa-shell" ? "spa" : props.mode;
				const shouldRunSetup = props.mode !== "ssg" && props.mode !== "spa-shell";
				if (process.env.ONE_RENDER_MODE !== renderMode) {
					process.env.ONE_RENDER_MODE = renderMode;
				}
				if (shouldRunSetup && !setupDone && options.getSetupPromise) {
					await options.getSetupPromise();
					setupDone = true;
				}
				if (!cachedServerRender) {
					const sr = await import("./server-render.mjs");
					cachedServerRender = sr;
					cachedRenderToStaticMarkup = sr.renderToStaticMarkup;
					cachedRenderToString = sr.renderToString;
				}
				const { loaderData, loaderProps, css, cssContents, mode, loaderServerData, routePreloads: routePreloads2, matches } = props;
				setServerContext({
					postRenderData: loaderServerData,
					loaderData,
					loaderProps,
					mode,
					css,
					cssContents,
					routePreloads: routePreloads2,
					matches
				});
				const rootElement = /* @__PURE__ */ jsx(Root, {
					flags: options.flags,
					routes: options.routes,
					routerRoot: options.routerRoot,
					linking: options.linking,
					...props
				});
				return cachedServerRender.renderToStream(rootElement, { preloads: props.preloads });
			}
		};
	}
	setupSkewProtection();
	const serverContext = getServerContext() || {};
	const routePreloads = serverContext.routePreloads;
	if (serverContext.matches) {
		const lastIndex = serverContext.matches.length - 1;
		const restoredMatches = serverContext.matches.map((m, index) => {
			if (index === lastIndex && m.loaderData === void 0 && serverContext.loaderData !== void 0) {
				return {
					...m,
					loaderData: serverContext.loaderData
				};
			}
			return m;
		});
		initClientMatches(restoredMatches);
	}
	const setupComplete = options.getSetupPromise ? options.getSetupPromise() : Promise.resolve();
	const preloadPromises = routePreloads ? Object.entries(routePreloads).map(async ([routeKey, bundlePath]) => {
		const mod = await import(
			/* @vite-ignore */
			bundlePath
);
		registerPreloadedRoute(routeKey, mod);
		return mod;
	}) : [findRootLayout(options.routes, options.routerRoot)];
	const one404Marker = window.__one404;
	if (one404Marker?.notFoundPath) {
		const currentState = window.history.state || {};
		window.history.replaceState({
			...currentState,
			__tempLocation: {
				pathname: one404Marker.notFoundPath,
				search: ""
			}
		}, "");
	}
	return setupComplete.then(() => Promise.all(preloadPromises)).then(() => {
		return resolveClientLoader(serverContext);
	}).then(() => {
		render(/* @__PURE__ */ jsx(Root, {
			isClient: true,
			flags: options.flags,
			routes: options.routes,
			routerRoot: options.routerRoot,
			linking: options.linking,
			path: window.location.href
		}));
	}).catch((err) => {
		console.error(`Error during client initialization:`, err);
		if (isChunkLoadError(err)) {
			handleSkewError();
		}
	});
}

export { createApp };
//# sourceMappingURL=createApp.mjs.map