one/dist/esm/createApp.js

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

import "./setup";
import { cloneElement } from "react";
import { AppRegistry } from "react-native-web";
import { resolveClientLoader } from "./clientLoaderResolver";
import { render } from "./render";
import { Root } from "./Root";
import { registerPreloadedRoute } from "./router/useViteRoutes";
import { getServerHeadInsertions } from "./useServerHeadInsertion";
import { ensureExists } from "./utils/ensureExists";
import { SERVER_CONTEXT_POST_RENDER_STRING } from "./vite/constants";
import { getServerContext, setServerContext } from "./vite/one-server-only";
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")
        ]), 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.js.map