one/dist/cjs/createApp.js

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"), import_react = require("react"), import_react_native = require("react-native-web"), import_clientLoaderResolver = require("./clientLoaderResolver"), import_render = require("./render"), import_Root = require("./Root"), import_useViteRoutes = require("./router/useViteRoutes"), import_useServerHeadInsertion = require("./useServerHeadInsertion"), import_ensureExists = require("./utils/ensureExists"), import_constants = require("./vite/constants"), import_one_server_only = require("./vite/one-server-only"), 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;
        let { 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(
          JSON.stringify(import_constants.SERVER_CONTEXT_POST_RENDER_STRING),
          JSON.stringify(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);
  });
}
//# sourceMappingURL=createApp.js.map