one
Version:
One is a new React Framework that makes Vite serve both native and web.
267 lines • 10.3 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all) __defProp(target, name, {
get: all[name],
enumerable: true
});
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from)) if (!__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: true
}) : target, mod));
var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
value: true
}), mod);
var createApp_exports = {};
__export(createApp_exports, {
createApp: () => createApp
});
module.exports = __toCommonJS(createApp_exports);
var import_setup = require("./setup.cjs");
var import_react = require("react");
var import_react_native = require("react-native-web");
var import_clientLoaderResolver = require("./clientLoaderResolver.cjs");
var import_Root = require("./Root.cjs");
var import_render = require("./render.cjs");
var import_router = require("./router/router.cjs");
var import_useViteRoutes = require("./router/useViteRoutes.cjs");
var import_skewProtection = require("./skewProtection.cjs");
var import_findRootLayout = require("./utils/findRootLayout.cjs");
var import_useServerHeadInsertion = require("./useServerHeadInsertion.cjs");
var import_constants = require("./vite/constants.cjs");
var import_htmlEscape = require("./utils/htmlEscape.cjs");
var import_one_server_only = require("./vite/one-server-only.cjs");
var import_jsx_runtime = require("react/jsx-runtime");
const import_meta = {};
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")]);
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;
(0, import_one_server_only.setServerContext)({
postRenderData: loaderServerData,
loaderData,
loaderProps,
mode,
css,
cssContents,
routePreloads: routePreloads2,
matches
});
let renderId;
const rootElement = /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_Root.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 {
import_react_native.AppRegistry.registerComponent("__oneStyles", () => () => null);
const app = import_react_native.AppRegistry.getApplication("__oneStyles", {});
const styleTag = app.getStyleElement({
nonce: process.env.ONE_NONCE
});
if (styleTag) {
extraHeadElements.push(styleTag);
}
} catch {}
if (renderId) {
const insertions = (0, import_useServerHeadInsertion.getServerHeadInsertions)(renderId);
if (insertions) {
for (const insertion of insertions) {
const out = insertion();
if (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
}))
}));
if (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;
if (postRenderData) {
html = html.replace((0, import_htmlEscape.safeJsonStringify)(import_constants.SERVER_CONTEXT_POST_RENDER_STRING), (0, import_htmlEscape.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")]);
cachedReactDOMServer = rds;
cachedServerRender = sr;
cachedRenderToStaticMarkup = rds.renderToStaticMarkup || rds.default?.renderToStaticMarkup;
cachedRenderToString = sr.renderToString;
}
const {
loaderData,
loaderProps,
css,
cssContents,
mode,
loaderServerData,
routePreloads: routePreloads2,
matches
} = props;
(0, import_one_server_only.setServerContext)({
postRenderData: loaderServerData,
loaderData,
loaderProps,
mode,
css,
cssContents,
routePreloads: routePreloads2,
matches
});
const rootElement = /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_Root.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();
}
});
}
(0, import_skewProtection.setupSkewProtection)();
const serverContext = (0, import_one_server_only.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;
});
(0, import_router.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);
(0, import_useViteRoutes.registerPreloadedRoute)(routeKey, mod);
return mod;
}) : [(0, import_findRootLayout.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 (0, import_clientLoaderResolver.resolveClientLoader)(serverContext);
}).then(() => {
(0, import_render.render)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_Root.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);
});
}