one/dist/esm/createApp.mjs

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

import { cloneElement } from "react";
import { AppRegistry } from "react-native-web";
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 { 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 cachedReactDOMServer;
    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 (!cachedReactDOMServer) {
          const [rds, sr] = await Promise.all([import("react-dom/server.browser"), import("./server-render.mjs")]);
          cachedReactDOMServer = rds;
          cachedServerRender = sr;
          cachedRenderToStaticMarkup = rds.renderToStaticMarkup || rds.default?.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,
          ...props
        });
        let html = await renderToString(rootElement, {
          preloads: props.preloads
        });
        try {
          const extraHeadElements = [];
          try {
            AppRegistry.registerComponent("__oneStyles", () => () => null);
            const app = AppRegistry.getApplication("__oneStyles", {});
            const styleTag = app.getStyleElement({
              nonce: process.env.ONE_NONCE
            });
            if (styleTag) {
              extraHeadElements.push(styleTag);
            }
          } catch {}
          if (renderId) {
            const insertions = getServerHeadInsertions(renderId);
            if (insertions) {
              for (const insertion of insertions) {
                const out = insertion();
                if (out) {
                  extraHeadElements.push(out);
                }
              }
            }
          }
          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>`);
            }
          }
        } catch (err) {
          if (!`${err}`.includes(`sheet is not defined`)) {
            throw err;
          }
        }
        const postRenderData = getServerContext()?.postRenderData;
        if (postRenderData) {
          html = html.replace(safeJsonStringify(SERVER_CONTEXT_POST_RENDER_STRING), safeJsonStringify(postRenderData));
        }
        return html;
      },
      // streaming SSR - returns ReadableStream, no post-processing
      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 [rds, sr] = await Promise.all([import("react-dom/server.browser"), import("./server-render.mjs")]);
          cachedReactDOMServer = rds;
          cachedServerRender = sr;
          cachedRenderToStaticMarkup = rds.renderToStaticMarkup || rds.default?.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,
          ...props
        });
        return cachedServerRender.renderToStream(rootElement, {
          preloads: props.preloads
        });
      }
    };
  }
  if (typeof window !== "undefined" && process.env.ONE_SKEW_PROTECTION !== "false") {
    window.addEventListener("vite:preloadError", e => {
      e.preventDefault();
      const key = "__one_skew_reload";
      const last = sessionStorage.getItem(key);
      if (!last || Date.now() - Number(last) > 1e4) {
        sessionStorage.setItem(key, String(Date.now()));
        window.location.reload();
      }
    });
  }
  setupSkewProtection();
  const serverContext = getServerContext() || {};
  const routePreloads = serverContext.routePreloads;
  if (serverContext.matches) {
    const restoredMatches = serverContext.matches.map(m => {
      if (!m.loaderData && serverContext.loaderData) {
        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,
      path: window.location.href
    }));
  }).catch(err => {
    console.error(`Error during client initialization:`, err);
  });
}
export { createApp };
//# sourceMappingURL=createApp.mjs.map