@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

package/dist/esm-node/core/browser/hydrate.mjs

@@ -0,0 +1,54 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { loadableReady } from "@loadable/component";
+import { RenderLevel } from "../constants.mjs";
+import { wrapRuntimeContextProvider } from "../react/wrapper.mjs";
+import { WithCallback } from "./withCallback.mjs";
+const isReact18 = ()=>'true' === process.env.IS_REACT18;
+function hydrateRoot(App, context, ModernRender, ModernHydrate) {
+    const hydrateContext = {
+        ...context,
+        get routes () {
+            return context.routes;
+        },
+        _hydration: true
+    };
+    const callback = ()=>{
+        delete hydrateContext._hydration;
+    };
+    const renderLevel = window?._SSR_DATA?.renderLevel || RenderLevel.CLIENT_RENDER;
+    const renderMode = window?._SSR_DATA?.mode || 'string';
+    if (isReact18() && 'stream' === renderMode) return streamSSRHydrate();
+    function streamSSRHydrate() {
+        if (renderLevel !== RenderLevel.SERVER_RENDER) return ModernRender(wrapRuntimeContextProvider(App, context));
+        {
+            const SSRApp = ()=>/*#__PURE__*/ jsx(WithCallback, {
+                    callback: callback,
+                    children: App
+                });
+            return ModernHydrate(wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext));
+        }
+    }
+    return stringSSRHydrate();
+    function stringSSRHydrate() {
+        if (renderLevel === RenderLevel.CLIENT_RENDER) return ModernRender(wrapRuntimeContextProvider(App, context));
+        if (renderLevel === RenderLevel.SERVER_RENDER) return new Promise((resolve)=>{
+            isReact18() ? loadableReady(()=>{
+                const SSRApp = ()=>/*#__PURE__*/ jsx(WithCallback, {
+                        callback: callback,
+                        children: App
+                    });
+                ModernHydrate(wrapRuntimeContextProvider(/*#__PURE__*/ jsx(SSRApp, {}), hydrateContext)).then((root)=>{
+                    resolve(root);
+                });
+            }) : loadableReady(()=>{
+                ModernHydrate(wrapRuntimeContextProvider(App, hydrateContext), callback).then((root)=>{
+                    resolve(root);
+                });
+            });
+        });
+        console.warn(`unknow render level: ${renderLevel}, execute render()`);
+        return ModernRender(wrapRuntimeContextProvider(App, context));
+    }
+}
+export { hydrateRoot, isReact18 };

package/dist/esm-node/core/browser/index.mjs

@@ -0,0 +1,105 @@
+import "node:module";
+import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
+import { parse } from "cookie";
+import { getGlobalInternalRuntimeContext } from "../context/index.mjs";
+import { getInitialContext } from "../context/runtime.mjs";
+import { wrapRuntimeContextProvider } from "../react/wrapper.mjs";
+import { hydrateRoot } from "./hydrate.mjs";
+const IS_REACT18 = 'true' === process.env.IS_REACT18;
+const getQuery = ()=>window.location.search.substring(1).split('&').reduce((res, item)=>{
+        const [key, value] = item.split('=');
+        if (key) res[key] = value;
+        return res;
+    }, {});
+const getCookieMap = ()=>{
+    const parsed = parse(document.cookie || '');
+    return Object.fromEntries(Object.entries(parsed).filter((entry)=>'string' == typeof entry[1]));
+};
+function getSSRData() {
+    const ssrData = window._SSR_DATA;
+    const ssrRequest = ssrData?.context?.request;
+    const finalSSRData = {
+        ...ssrData || {
+            renderLevel: 0,
+            mode: 'string'
+        },
+        context: {
+            ...ssrData?.context || {},
+            request: {
+                ...ssrData?.context?.request || {},
+                params: ssrRequest?.params || {},
+                host: ssrRequest?.host || location.host,
+                pathname: ssrRequest?.pathname || location.pathname,
+                headers: ssrRequest?.headers || {},
+                cookieMap: getCookieMap(),
+                cookie: document.cookie || '',
+                userAgent: ssrRequest?.headers?.['user-agent'] || navigator.userAgent,
+                referer: document.referrer,
+                query: {
+                    ...getQuery(),
+                    ...ssrRequest?.query || {}
+                },
+                url: location.href
+            }
+        }
+    };
+    return finalSSRData;
+}
+function isClientArgs(id) {
+    return void 0 === id || 'string' == typeof id || "u" > typeof HTMLElement && id instanceof HTMLElement;
+}
+async function render(App, id) {
+    const context = getInitialContext();
+    const runBeforeRender = async (context)=>{
+        const internalRuntimeContext = getGlobalInternalRuntimeContext();
+        const api = internalRuntimeContext.pluginAPI;
+        api.updateRuntimeContext(context);
+        const hooks = internalRuntimeContext.hooks;
+        await hooks.onBeforeRender.call(context);
+    };
+    if (isClientArgs(id)) {
+        const ssrData = getSSRData();
+        Object.assign(context, {
+            _internalRouterBaseName: App.props.basename,
+            ssrContext: ssrData.context,
+            initialData: ssrData.data?.initialData
+        });
+        await runBeforeRender(context);
+        const rootElement = id && 'string' != typeof id ? id : document.getElementById(id || 'root');
+        async function ModernRender(App) {
+            const renderFunc = IS_REACT18 ? renderWithReact18 : renderWithReact17;
+            return renderFunc(App, rootElement);
+        }
+        async function ModernHydrate(App, callback) {
+            const hydrateFunc = IS_REACT18 ? hydrateWithReact18 : hydrateWithReact17;
+            return hydrateFunc(App, rootElement, callback);
+        }
+        if (window._SSR_DATA) return hydrateRoot(App, context, ModernRender, ModernHydrate);
+        return ModernRender(wrapRuntimeContextProvider(App, context));
+    }
+    throw Error('`render` function needs id in browser environment, it needs to be string or element');
+}
+async function renderWithReact18(App, rootElement) {
+    const ReactDOM = await import("react-dom/client");
+    const root = ReactDOM.createRoot(rootElement);
+    root.render(App);
+    return root;
+}
+async function renderWithReact17(App, rootElement) {
+    const ReactDOM = await import("react-dom");
+    ReactDOM.render(App, rootElement);
+    return rootElement;
+}
+async function hydrateWithReact18(App, rootElement) {
+    const ReactDOM = await import("react-dom/client");
+    const root = ReactDOM.hydrateRoot(rootElement, App, {
+        identifierPrefix: SSR_HYDRATION_ID_PREFIX
+    });
+    return root;
+}
+async function hydrateWithReact17(App, rootElement, callback) {
+    const ReactDOM = await import("react-dom");
+    const root = ReactDOM.hydrate(App, rootElement, callback);
+    return root;
+}
+export { hydrateWithReact17, hydrateWithReact18, render, renderWithReact17, renderWithReact18 };

package/dist/esm-node/core/browser/withCallback.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+import { useLayoutEffect, useRef } from "react";
+const WithCallback = ({ callback, children })=>{
+    const once = useRef(false);
+    useLayoutEffect(()=>{
+        if (once.current) return;
+        once.current = true;
+        callback();
+    }, [
+        callback
+    ]);
+    return children;
+};
+export { WithCallback };

package/dist/esm-node/core/compat/hooks.mjs

@@ -0,0 +1,36 @@
+import "node:module";
+function transformHookRunner(hookRunnerName) {
+    switch(hookRunnerName){
+        case 'beforeRender':
+            return 'onBeforeRender';
+        default:
+            return hookRunnerName;
+    }
+}
+function handleSetupResult(setupResult, api) {
+    if (!setupResult) return;
+    Object.keys(setupResult).forEach((key)=>{
+        const fn = setupResult[key];
+        if ('function' == typeof fn) {
+            const newAPI = transformHookRunner(key);
+            if (api[newAPI]) if ('beforeRender' === key) api[newAPI](async (...params)=>{
+                await fn(...params);
+            });
+            else api[newAPI]((...params)=>{
+                const res = fn(...params);
+                return res;
+            });
+        }
+    });
+}
+function getHookRunners(runtimeContext) {
+    const { _internalContext } = runtimeContext;
+    const { hooks } = _internalContext;
+    return {
+        beforeRender: async (context)=>hooks.onBeforeRender.call(context),
+        wrapRoot: (App)=>hooks.wrapRoot.call(App),
+        pickContext: (context)=>hooks.pickContext.call(context),
+        config: ()=>hooks.config.call()
+    };
+}
+export { getHookRunners, handleSetupResult, transformHookRunner };

package/dist/esm-node/core/compat/index.mjs

@@ -0,0 +1,13 @@
+import "node:module";
+import { getHookRunners } from "./hooks.mjs";
+const compatPlugin = ()=>({
+        name: '@modern-js/runtime-plugin-compat',
+        _registryApi: (getRuntimeContext)=>({
+                useRuntimeConfigContext: ()=>{
+                    const { _internalContext } = getRuntimeContext();
+                    return _internalContext.config;
+                },
+                useHookRunners: ()=>getHookRunners(getRuntimeContext())
+            })
+    });
+export { compatPlugin };

package/dist/esm-node/core/compat/requestContext.mjs

@@ -0,0 +1,23 @@
+import "node:module";
+const makeRequestContext = (context)=>{
+    const baseSSRContext = context.ssrContext;
+    if (baseSSRContext) return {
+        request: baseSSRContext.request,
+        response: baseSSRContext.response
+    };
+    return {
+        request: {},
+        response: {}
+    };
+};
+const requestContextPlugin = ()=>({
+        name: '@modern-js/runtime-plugin-request-context',
+        setup (api) {
+            api.onBeforeRender((context)=>{
+                const requestContext = makeRequestContext(context);
+                context.requestContext = requestContext;
+                context.context = requestContext;
+            });
+        }
+    });
+export { makeRequestContext, requestContextPlugin };

package/dist/esm-node/core/config.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+const defineRuntimeConfig = (config)=>config;
+export { defineRuntimeConfig };

package/dist/esm-node/core/constants.mjs

@@ -0,0 +1,9 @@
+import "node:module";
+var constants_RenderLevel = /*#__PURE__*/ function(RenderLevel) {
+    RenderLevel[RenderLevel["CLIENT_RENDER"] = 0] = "CLIENT_RENDER";
+    RenderLevel[RenderLevel["SERVER_RENDER"] = 2] = "SERVER_RENDER";
+    return RenderLevel;
+}({});
+const SSR_DATA_JSON_ID = '__MODERN_SSR_DATA__';
+const ROUTER_DATA_JSON_ID = '__MODERN_ROUTER_DATA__';
+export { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID, constants_RenderLevel as RenderLevel };

package/dist/esm-node/core/context/index.mjs

@@ -0,0 +1,46 @@
+import "node:module";
+const globalContext = {};
+function getGlobalIsRscClient() {
+    return globalContext.isRscClient;
+}
+function getGlobalEnableRsc() {
+    return globalContext.enableRsc;
+}
+function setGlobalContext(context) {
+    globalContext.entryName = context.entryName;
+    globalContext.App = context.App;
+    globalContext.routes = context.routes;
+    globalContext.appInit = context.appInit;
+    globalContext.layoutApp = context.layoutApp;
+    globalContext.basename = context.basename;
+    globalContext.RSCRoot = context.RSCRoot;
+    globalContext.isRscClient = context.isRscClient;
+    globalContext.enableRsc = context.enableRsc;
+}
+function getCurrentEntryName() {
+    return globalContext.entryName;
+}
+function getGlobalRSCRoot() {
+    return globalContext.RSCRoot;
+}
+function setGlobalInternalRuntimeContext(context) {
+    globalContext.internalRuntimeContext = context;
+}
+function getGlobalInternalRuntimeContext() {
+    return globalContext.internalRuntimeContext;
+}
+function getGlobalApp() {
+    return globalContext.App;
+}
+function getGlobalRoutes() {
+    return globalContext.routes;
+}
+function getGlobalLayoutApp() {
+    return globalContext.layoutApp;
+}
+function getGlobalBasename() {
+    return globalContext.basename;
+}
+export { InternalRuntimeContext, RuntimeContext, getInitialContext } from "./runtime.mjs";
+export { getServerPayload, setServerPayload } from "./serverPayload/index.mjs";
+export { getCurrentEntryName, getGlobalApp, getGlobalBasename, getGlobalEnableRsc, getGlobalInternalRuntimeContext, getGlobalIsRscClient, getGlobalLayoutApp, getGlobalRSCRoot, getGlobalRoutes, setGlobalContext, setGlobalInternalRuntimeContext };

package/dist/esm-node/core/context/monitors/default.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+const defaultMonitors = {
+    counter (name) {},
+    info: console.info,
+    debug: console.debug,
+    trace: console.trace,
+    warn: console.warn,
+    error: console.error,
+    timing (name, dur) {}
+};
+export { defaultMonitors };

package/dist/esm-node/core/context/monitors/index.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+import { defaultMonitors } from "./default.mjs";
+const getMonitors = ()=>defaultMonitors;
+export { getMonitors };

package/dist/esm-node/core/context/monitors/index.server.mjs

@@ -0,0 +1,8 @@
+import "node:module";
+import { storage } from "@modern-js/runtime-utils/node";
+import { defaultMonitors } from "./default.mjs";
+const getMonitors = ()=>{
+    const storageContext = storage.useContext();
+    return storageContext.monitors || defaultMonitors;
+};
+export { getMonitors };

package/dist/esm-node/core/context/request/index.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+const getRequest = ()=>new Request(location.href);
+export { getRequest };

package/dist/esm-node/core/context/request/index.server.mjs

@@ -0,0 +1,7 @@
+import "node:module";
+import { storage } from "@modern-js/runtime-utils/node";
+const getRequest = ()=>{
+    const context = storage.useContext();
+    return context?.request;
+};
+export { getRequest };

package/dist/esm-node/core/context/response/index.mjs

@@ -0,0 +1,8 @@
+import "node:module";
+const getResponseProxy = ()=>null;
+const setHeaders = (headers)=>{};
+const setStatus = (status)=>{};
+const redirect = (url, init)=>{
+    console.warn("You should not use this API in the browser, please use the router's redirect or useNavigate method.");
+};
+export { getResponseProxy, redirect, setHeaders, setStatus };

package/dist/esm-node/core/context/response/index.server.mjs

@@ -0,0 +1,29 @@
+import "node:module";
+import { storage } from "@modern-js/runtime-utils/node";
+const getResponseProxy = ()=>{
+    const context = storage.useContext();
+    return context?.responseProxy;
+};
+const setHeaders = (headers)=>{
+    const responseProxy = getResponseProxy();
+    Object.entries(headers).forEach(([key, value])=>{
+        responseProxy.headers[key] = value;
+    });
+};
+const setStatus = (status)=>{
+    const responseProxy = getResponseProxy();
+    responseProxy.status = status;
+};
+const redirect = (url, init)=>{
+    const status = void 0 === init ? 307 : 'number' == typeof init ? init : init.status ?? 307;
+    const headers = void 0 === init ? {} : 'number' == typeof init ? {} : init.headers ?? {};
+    setStatus(status);
+    setHeaders({
+        Location: url,
+        ...init && 'object' == typeof init ? Object.fromEntries(Object.entries(headers).map(([k, v])=>[
+                k,
+                String(v)
+            ])) : {}
+    });
+};
+export { getResponseProxy, redirect, setHeaders, setStatus };

package/dist/esm-node/core/context/runtime.mjs

@@ -0,0 +1,20 @@
+import "node:module";
+import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
+import { createContext, useContext } from "react";
+const InternalRuntimeContext = createContext({});
+const RuntimeContext = createContext({});
+const ReactRuntimeContext = RuntimeContext;
+const getInitialContext = (isBrowser = true, routeManifest)=>{
+    const requestContext = {
+        request: {},
+        response: {}
+    };
+    return {
+        isBrowser,
+        routeManifest: routeManifest || "u" > typeof window && window[ROUTE_MANIFEST],
+        requestContext,
+        context: requestContext
+    };
+};
+const useRuntimeContext = ()=>useContext(RuntimeContext);
+export { InternalRuntimeContext, ReactRuntimeContext, RuntimeContext, getInitialContext, useRuntimeContext };

package/dist/esm-node/core/context/serverPayload/index.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+const getServerPayload = ()=>{};
+const setServerPayload = (payload)=>{};
+export { getServerPayload, setServerPayload };

package/dist/esm-node/core/context/serverPayload/index.server.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+import { storage } from "@modern-js/runtime-utils/node";
+const getServerPayload = ()=>{
+    const context = storage.useContext();
+    return context?.serverPayload;
+};
+const setServerPayload = (payload)=>{
+    const context = storage.useContext();
+    if (context) context.serverPayload = payload;
+};
+export { getServerPayload, setServerPayload };

package/dist/esm-node/core/index.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+export { defineRuntimeConfig } from "./config.mjs";
+export { RuntimeContext, useRuntimeContext } from "./context/runtime.mjs";

package/dist/esm-node/core/plugin/index.mjs

@@ -0,0 +1,26 @@
+import "node:module";
+import { runtime } from "@modern-js/plugin/runtime";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { compatPlugin } from "../compat/index.mjs";
+import { handleSetupResult } from "../compat/hooks.mjs";
+import { requestContextPlugin } from "../compat/requestContext.mjs";
+import { setGlobalInternalRuntimeContext } from "../context/index.mjs";
+function registerPlugin(internalPlugins, runtimeConfig) {
+    const { plugins = [] } = runtimeConfig || {};
+    const { runtimeContext } = runtime.run({
+        plugins: [
+            compatPlugin(),
+            requestContextPlugin(),
+            ...internalPlugins,
+            ...plugins
+        ],
+        config: runtimeConfig || {},
+        handleSetupResult: handleSetupResult
+    });
+    setGlobalInternalRuntimeContext(runtimeContext);
+    return runtimeContext;
+}
+function mergeConfig(config, ...otherConfig) {
+    return merge({}, config, ...otherConfig);
+}
+export { mergeConfig, registerPlugin };

package/dist/esm-node/core/plugin/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/core/react/index.mjs

@@ -0,0 +1,17 @@
+import "node:module";
+import { parsedJSONFromElement } from "@modern-js/runtime-utils/parsed";
+import { isBrowser } from "../../common.mjs";
+import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../constants.mjs";
+import { getGlobalApp, getGlobalInternalRuntimeContext } from "../context/index.mjs";
+function createRoot(UserApp) {
+    const App = UserApp || getGlobalApp();
+    if (isBrowser()) {
+        window._SSR_DATA = window._SSR_DATA || parsedJSONFromElement(SSR_DATA_JSON_ID);
+        window._ROUTER_DATA = window._ROUTER_DATA || parsedJSONFromElement(ROUTER_DATA_JSON_ID);
+    }
+    const internalRuntimeContext = getGlobalInternalRuntimeContext();
+    const hooks = internalRuntimeContext.hooks;
+    const WrapperApp = hooks.wrapRoot.call(App);
+    return WrapperApp;
+}
+export { createRoot };

package/dist/esm-node/core/react/wrapper.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { InternalRuntimeContext, RuntimeContext } from "../context/index.mjs";
+function wrapRuntimeContextProvider(App, contextValue) {
+    const { isBrowser, initialData, routes, routerFramework, context, routeManifest, routerRuntime, routerInstance, routerHydrationScript, routerMatchedRouteIds, routerServerSnapshot, routerContext, unstable_getBlockNavState, ssrContext, _internalContext, _internalRouterBaseName, ...rest } = contextValue;
+    const runtimeContextValue = {
+        isBrowser,
+        initialData,
+        routes,
+        routerFramework,
+        context,
+        ...rest
+    };
+    return /*#__PURE__*/ jsx(InternalRuntimeContext.Provider, {
+        value: contextValue,
+        children: /*#__PURE__*/ jsx(RuntimeContext.Provider, {
+            value: runtimeContextValue,
+            children: App
+        })
+    });
+}
+export { wrapRuntimeContextProvider };

package/dist/esm-node/core/server/constants.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+const HTML_PLACEHOLDER = '<!--<?- html ?>-->';
+const SSR_DATA_PLACEHOLDER = '<!--<?- SSRDataScript ?>-->';
+const CHUNK_JS_PLACEHOLDER = '<!--<?- chunksMap.js ?>-->';
+const CHUNK_CSS_PLACEHOLDER = '<!--<?- chunksMap.css ?>-->';
+export { CHUNK_CSS_PLACEHOLDER, CHUNK_JS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER };

package/dist/esm-node/core/server/helmet.mjs

@@ -0,0 +1,39 @@
+import "node:module";
+import { EOL } from "os";
+import { safeReplace } from "./utils.mjs";
+const RE_HTML_ATTR = /<html[^>]*>/;
+const RE_BODY_ATTR = /<body[^>]*>/;
+const RE_LAST_IN_HEAD = /<\/head>/;
+const RE_TITLE = /<title[^>]*>([\s\S\n\r]*?)<\/title>/;
+const TEST_TITLE_CONTENT = /(?<=<title[^>]*>)([\s\S\n\r]*?)([.|\S])([\s\S\n\r]*?)(?=<\/title>)/;
+function createReplaceHelemt(helmetData) {
+    return helmetData ? (template)=>helmetReplace(template, helmetData) : (tempalte)=>tempalte;
+}
+function helmetReplace(content, helmetData) {
+    let result = content;
+    const bodyAttributes = helmetData.bodyAttributes.toString();
+    if (bodyAttributes) result = safeReplace(result, RE_BODY_ATTR, `<body ${bodyAttributes}>`);
+    const htmlAttributes = helmetData.htmlAttributes.toString();
+    if (htmlAttributes) result = safeReplace(result, RE_HTML_ATTR, `<html ${htmlAttributes}>`);
+    const base = helmetData.base.toString();
+    const link = helmetData.link.toString();
+    const meta = helmetData.meta.toString();
+    const noscript = helmetData.noscript.toString();
+    const script = helmetData.script.toString();
+    const style = helmetData.style.toString();
+    const title = helmetData.title.toString();
+    const existTitleTag = RE_TITLE.test(content);
+    const shouldReplaceTitle = existTitleTag && TEST_TITLE_CONTENT.test(title.trim());
+    if (shouldReplaceTitle) result = safeReplace(result, RE_TITLE, title);
+    const helmetStr = [
+        base,
+        link,
+        meta,
+        noscript,
+        script,
+        style,
+        !existTitleTag ? title : ''
+    ].reduce((pre, cur)=>pre + (cur.length > 0 ? `  ${cur}${EOL}` : ''), '');
+    return safeReplace(result, RE_LAST_IN_HEAD, `${helmetStr}</head>`);
+}
+export { createReplaceHelemt, helmetReplace };

package/dist/esm-node/core/server/index.mjs

@@ -0,0 +1,9 @@
+import "node:module";
+const ssr = (_config)=>({
+        name: '@modern-js/plugin-ssr',
+        setup: (_api)=>{}
+    });
+const server = ssr;
+export { NoSSR, NoSSRCache } from "./react/index.mjs";
+export default server;
+export { ssr };

package/dist/esm-node/core/server/react/index.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+export { NoSSRCache } from "./no-ssr-cache/index.mjs";
+export { NoSSR } from "./nossr/index.mjs";

package/dist/esm-node/core/server/react/no-ssr-cache/index.mjs

@@ -0,0 +1,10 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { Helmet } from "../../../../exports/head.mjs";
+const NoSSRCache = ()=>/*#__PURE__*/ jsx(Helmet, {
+        children: /*#__PURE__*/ jsx("meta", {
+            name: "no-ssr-cache"
+        })
+    });
+export { NoSSRCache };

package/dist/esm-node/core/server/react/nossr/index.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+import react, { useEffect, useState } from "react";
+const NoSSR = (props)=>{
+    const [isMounted, setMounted] = useState(false);
+    useEffect(()=>{
+        setMounted(true);
+    }, []);
+    const { children, fallback = null } = props || {};
+    return react.createElement(react.Fragment, null, isMounted ? children : fallback);
+};
+export { NoSSR };