one/dist/cjs/createApp.cjs

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

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf,
  __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
    for (var name in all) __defProp(target, name, {
      get: all[name],
      enumerable: !0
    });
  },
  __copyProps = (to, from, except, desc) => {
    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
      get: () => from[key],
      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
    });
    return to;
  };
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
    value: mod,
    enumerable: !0
  }) : target, mod)),
  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
    value: !0
  }), mod);
var createApp_exports = {};
__export(createApp_exports, {
  createApp: () => createApp
});
module.exports = __toCommonJS(createApp_exports);
var import_setup = require("./setup.cjs"),
  import_react = require("react"),
  import_react_native = require("react-native-web"),
  import_clientLoaderResolver = require("./clientLoaderResolver.cjs"),
  import_Root = require("./Root.cjs"),
  import_render = require("./render.cjs"),
  import_useViteRoutes = require("./router/useViteRoutes.cjs"),
  import_useServerHeadInsertion = require("./useServerHeadInsertion.cjs"),
  import_ensureExists = require("./utils/ensureExists.cjs"),
  import_htmlEscape = require("./utils/htmlEscape.cjs"),
  import_constants = require("./vite/constants.cjs"),
  import_one_server_only = require("./vite/one-server-only.cjs"),
  import_jsx_runtime = require("react/jsx-runtime");
const import_meta = {};
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,
        {
          loaderData,
          loaderProps,
          css,
          cssContents,
          mode,
          loaderServerData,
          routePreloads: routePreloads2
        } = props;
      (0, import_one_server_only.setServerContext)({
        postRenderData: loaderServerData,
        loaderData,
        loaderProps,
        mode,
        css,
        cssContents,
        routePreloads: routePreloads2
      });
      let renderId;
      const App = () => /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_Root.Root, {
        flags: options.flags,
        onRenderId: id => {
          renderId = id;
        },
        routes: options.routes,
        routerRoot: options.routerRoot,
        ...props
      });
      import_react_native.AppRegistry.registerComponent("App", () => App);
      const Application = import_react_native.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), (0, import_ensureExists.ensureExists)(renderId);
        const insertions = (0, import_useServerHeadInsertion.getServerHeadInsertions)(renderId);
        if (insertions) for (const insertion of insertions) {
          const out = insertion();
          out && extraHeadElements.push(out);
        }
        if (extraHeadElements.length) {
          const extraHeadHTML = renderToStaticMarkup(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
            children: extraHeadElements.map((x, i) => (0, import_react.cloneElement)(x, {
              key: i
            }))
          }));
          extraHeadHTML && (html = html.replace("</head>", `${extraHeadHTML}</head>`));
        }
      } catch (err) {
        if (!`${err}`.includes("sheet is not defined")) throw err;
      }
      const postRenderData = (0, import_one_server_only.getServerContext)()?.postRenderData;
      return postRenderData && (html = html.replace((0, import_htmlEscape.safeJsonStringify)(import_constants.SERVER_CONTEXT_POST_RENDER_STRING), (0, import_htmlEscape.safeJsonStringify)(postRenderData))), html;
    }
  };
  const serverContext = (0, import_one_server_only.getServerContext)() || {},
    routePreloads = serverContext.routePreloads,
    preloadPromises = routePreloads ? Object.entries(routePreloads).map(async ([routeKey, bundlePath]) => {
      const mod = await import(/* @vite-ignore */
      bundlePath);
      return (0, import_useViteRoutes.registerPreloadedRoute)(routeKey, mod), mod;
    }) : [options.routes[`/${options.routerRoot}/_layout.tsx`]?.()];
  return Promise.all(preloadPromises).then(() => (0, import_clientLoaderResolver.resolveClientLoader)(serverContext)).then(() => {
    (0, import_render.render)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_Root.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);
  });
}