one/dist/esm/createApp.mjs

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

import "./setup.mjs";
import { cloneElement } from "react";
import { AppRegistry } from "react-native-web";
import { resolveClientLoader } from "./clientLoaderResolver.mjs";
import { render } from "./render.mjs";
import { Root } from "./Root.mjs";
import { registerPreloadedRoute } from "./router/useViteRoutes.mjs";
import { getServerHeadInsertions } from "./useServerHeadInsertion.mjs";
import { ensureExists } from "./utils/ensureExists.mjs";
import { SERVER_CONTEXT_POST_RENDER_STRING } from "./vite/constants.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) return {
    options,
    render: async props => {
      const [ReactDOMServer, serverRender] = await Promise.all([import("react-dom/server.browser"), import("./server-render.mjs")]),
        renderToStaticMarkup = ReactDOMServer.renderToStaticMarkup || ReactDOMServer.default?.renderToStaticMarkup,
        renderToString = serverRender.renderToString;
      let {
        loaderData,
        loaderProps,
        css,
        cssContents,
        mode,
        loaderServerData,
        routePreloads: routePreloads2
      } = props;
      setServerContext({
        postRenderData: loaderServerData,
        loaderData,
        loaderProps,
        mode,
        css,
        cssContents,
        routePreloads: routePreloads2
      });
      let renderId;
      const App = () => /* @__PURE__ */jsx(Root, {
        flags: options.flags,
        onRenderId: id => {
          renderId = id;
        },
        routes: options.routes,
        routerRoot: options.routerRoot,
        ...props
      });
      AppRegistry.registerComponent("App", () => App);
      const Application = AppRegistry.getApplication("App", {}),
        rootElement = Application.element.props.children;
      let html = await renderToString(rootElement, {
        preloads: props.preloads,
        deferredPreloads: props.deferredPreloads
      });
      try {
        const extraHeadElements = [],
          styleTag = Application.getStyleElement({
            nonce: process.env.ONE_NONCE
          });
        styleTag && extraHeadElements.push(styleTag), ensureExists(renderId);
        const insertions = getServerHeadInsertions(renderId);
        if (insertions) for (const insertion of insertions) {
          const out = insertion();
          out && extraHeadElements.push(out);
        }
        if (extraHeadElements.length) {
          const extraHeadHTML = renderToStaticMarkup(/* @__PURE__ */jsx(Fragment, {
            children: extraHeadElements.map((x, i) => cloneElement(x, {
              key: i
            }))
          }));
          extraHeadHTML && (html = html.replace("</head>", `${extraHeadHTML}</head>`));
        }
      } catch (err) {
        if (!`${err}`.includes("sheet is not defined")) throw err;
      }
      const postRenderData = getServerContext()?.postRenderData;
      return postRenderData && (html = html.replace(JSON.stringify(SERVER_CONTEXT_POST_RENDER_STRING), JSON.stringify(postRenderData))), html;
    }
  };
  const serverContext = getServerContext() || {},
    routePreloads = serverContext.routePreloads,
    preloadPromises = routePreloads ? Object.entries(routePreloads).map(async ([routeKey, bundlePath]) => {
      const mod = await import(/* @vite-ignore */
      bundlePath);
      return registerPreloadedRoute(routeKey, mod), mod;
    }) : [options.routes[`/${options.routerRoot}/_layout.tsx`]?.()];
  return Promise.all(preloadPromises).then(() => resolveClientLoader(serverContext)).then(() => {
    render(/* @__PURE__ */jsx(Root, {
      isClient: !0,
      flags: options.flags,
      routes: options.routes,
      routerRoot: options.routerRoot,
      path: window.location.href
    }));
  }).catch(err => {
    console.error("Error during client initialization:", err);
  });
}
export { createApp };
//# sourceMappingURL=createApp.mjs.map