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

package/dist/esm-node/router/runtime/tanstack/rsc/client.mjs

@@ -0,0 +1,54 @@
+import "node:module";
+"use client";
+import { createSerializationAdapter } from "@tanstack/react-router";
+import { use } from "react";
+import { createRscProxy } from "./createRscProxy.mjs";
+let modernRscClientRuntimePromise;
+function loadModernRscClientRuntime() {
+    modernRscClientRuntimePromise ??= import("../../../../rsc/client.mjs").then((runtime)=>{
+        runtime.setServerCallback(runtime.callServer);
+        return runtime;
+    });
+    return modernRscClientRuntimePromise;
+}
+function createTreeGetter(stream) {
+    let ready = false;
+    let tree;
+    const treePromise = loadModernRscClientRuntime().then((runtime)=>runtime.createFromReadableStream(stream, {
+            callServer: runtime.callServer
+        })).then((value)=>{
+        tree = value;
+        ready = true;
+        return value;
+    });
+    return ()=>{
+        if (ready) return tree;
+        return use(treePromise);
+    };
+}
+function createFromFlightStream(serialized) {
+    const streamWrapper = {
+        createReplayStream: ()=>serialized.stream
+    };
+    return createRscProxy(createTreeGetter(serialized.stream), {
+        renderable: 'renderable' === serialized.kind,
+        slotUsagesStream: serialized.slotUsagesStream,
+        stream: streamWrapper
+    });
+}
+const adapter = createSerializationAdapter({
+    key: '$MODERN_TANSTACK_RSC',
+    test: (_value)=>false,
+    toSerializable: ()=>{
+        throw new Error('TanStack RSC data cannot be serialized on client.');
+    },
+    fromSerializable: (value)=>createFromFlightStream(value)
+});
+function getTanstackRscSerializationAdapters() {
+    return [
+        adapter
+    ];
+}
+const rscSerializationAdapter = getTanstackRscSerializationAdapters;
+export { CompositeComponent } from "./CompositeComponent.mjs";
+export { getTanstackRscSerializationAdapters, rscSerializationAdapter };

package/dist/esm-node/router/runtime/tanstack/rsc/createRscProxy.mjs

@@ -0,0 +1,108 @@
+import "node:module";
+"use client";
+import { createElement } from "react";
+import { RscNodeRenderer } from "./RscNodeRenderer.mjs";
+import { RENDERABLE_RSC, RSC_PROXY_GET_TREE, RSC_PROXY_PATH, RSC_SLOT_USAGES, RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM } from "./symbols.mjs";
+const UNHANDLED = Symbol('modern.tanstack.rsc.unhandled');
+function handleProxyTrap(kind, prop, options) {
+    switch(prop){
+        case '__SEROVAL_STREAM__':
+        case '__SEROVAL_SEQUENCE__':
+        case Symbol.iterator:
+        case Symbol.asyncIterator:
+            return 'get' === kind ? void 0 : false;
+        case SERVER_COMPONENT_STREAM:
+            return 'get' === kind ? options.stream : Boolean(options.stream);
+        case RENDERABLE_RSC:
+            return 'get' === kind ? options.renderable : true;
+        case RSC_PROXY_GET_TREE:
+            return 'get' === kind ? options.getTree : true;
+        case RSC_PROXY_PATH:
+            return 'get' === kind ? options.path : true;
+        case RSC_SLOT_USAGES_STREAM:
+            return 'get' === kind ? options.slotUsagesStream : Boolean(options.slotUsagesStream);
+        case RSC_SLOT_USAGES:
+            return 'get' === kind ? options.slotUsages : Boolean(options.slotUsages);
+        case 'then':
+            return 'get' === kind ? void 0 : UNHANDLED;
+        case 'toString':
+            return 'get' === kind ? Object.prototype.toString : UNHANDLED;
+        case 'valueOf':
+            return 'get' === kind ? Object.prototype.valueOf : UNHANDLED;
+        case 'constructor':
+            return 'get' === kind ? Object : UNHANDLED;
+        default:
+            return UNHANDLED;
+    }
+}
+function createRscProxyInternal(options) {
+    const childCache = new Map();
+    const dataProxy = options.renderable ? createRscProxyInternal({
+        ...options,
+        renderable: false
+    }) : void 0;
+    const target = options.renderable ? /*#__PURE__*/ createElement(RscNodeRenderer, {
+        data: dataProxy
+    }) : {};
+    const getChild = (key)=>{
+        if (!childCache.has(key)) childCache.set(key, createRscProxyInternal({
+            ...options,
+            path: [
+                ...options.path,
+                key
+            ]
+        }));
+        return childCache.get(key);
+    };
+    return new Proxy(target, {
+        get (proxyTarget, prop) {
+            const handled = handleProxyTrap('get', prop, options);
+            if (handled !== UNHANDLED) return handled;
+            if (options.renderable) {
+                if ('props' === prop) return proxyTarget.props;
+                if ('data' === prop) return dataProxy;
+                if (prop in proxyTarget) return proxyTarget[prop];
+            }
+            if ('symbol' == typeof prop) return;
+            return getChild(prop);
+        },
+        getOwnPropertyDescriptor (proxyTarget, prop) {
+            return options.renderable ? Object.getOwnPropertyDescriptor(proxyTarget, prop) : void 0;
+        },
+        getPrototypeOf (proxyTarget) {
+            return options.renderable ? Object.getPrototypeOf(proxyTarget) : Object.prototype;
+        },
+        has (proxyTarget, prop) {
+            const handled = handleProxyTrap('has', prop, options);
+            if (handled !== UNHANDLED) return Boolean(handled);
+            if (options.renderable) return prop in proxyTarget || 'string' == typeof prop;
+            return 'string' == typeof prop;
+        },
+        ownKeys (proxyTarget) {
+            return options.renderable ? Reflect.ownKeys(proxyTarget) : [];
+        }
+    });
+}
+function createRscProxy(getTree, options = {}) {
+    const slotUsages = 'development' === process.env.NODE_ENV && options.slotUsagesStream ? options.slotUsages ?? [] : options.slotUsages;
+    if ('development' === process.env.NODE_ENV && options.slotUsagesStream && slotUsages) consumeSlotUsages(options.slotUsagesStream, slotUsages);
+    return createRscProxyInternal({
+        getTree,
+        path: [],
+        renderable: true === options.renderable,
+        slotUsages,
+        slotUsagesStream: options.slotUsagesStream,
+        stream: options.stream
+    });
+}
+async function consumeSlotUsages(stream, slotUsages) {
+    try {
+        const reader = stream.getReader();
+        for(;;){
+            const { value, done } = await reader.read();
+            if (done) break;
+            if (value?.slot) slotUsages.push(value);
+        }
+    } catch  {}
+}
+export { createRscProxy };

package/dist/esm-node/router/runtime/tanstack/rsc/index.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { CompositeComponent, getTanstackRscSerializationAdapters, rscSerializationAdapter } from "./client.mjs";

package/dist/esm-node/router/runtime/tanstack/rsc/server.mjs

@@ -0,0 +1,201 @@
+import "node:module";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { createSerializationAdapter } from "@tanstack/react-router";
+import { RawStream } from "@tanstack/router-core";
+import { createElement, use } from "react";
+import { createFromReadableStream, renderRsc } from "../../../../rsc/server.mjs";
+import { ClientSlot } from "./ClientSlot.mjs";
+import { createRscProxy } from "./createRscProxy.mjs";
+import { ReplayableStream } from "./ReplayableStream.mjs";
+import { sanitizeSlotArgs } from "./slotUsageSanitizer.mjs";
+import { RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM, isRenderableServerComponent, isServerComponent } from "./symbols.mjs";
+function createTreeGetter(stream) {
+    let ready = false;
+    let tree;
+    const treePromise = Promise.resolve(createFromReadableStream(stream.createReplayStream())).then((value)=>{
+        tree = value;
+        ready = true;
+        return value;
+    });
+    return ()=>{
+        if (ready) return tree;
+        return use(treePromise);
+    };
+}
+function createSlotProxy(options) {
+    const cache = new Map();
+    return new Proxy({}, {
+        get (_target, prop) {
+            if ('then' === prop || 'string' != typeof prop) return;
+            if ('children' === prop) {
+                options?.onSlotCall?.('children', []);
+                return /*#__PURE__*/ createElement(ClientSlot, {
+                    args: [],
+                    slot: 'children'
+                });
+            }
+            if (!cache.has(prop)) cache.set(prop, (...args)=>{
+                options?.onSlotCall?.(prop, args);
+                return /*#__PURE__*/ createElement(ClientSlot, {
+                    args,
+                    slot: prop
+                });
+            });
+            return cache.get(prop);
+        }
+    });
+}
+function toReplayableFlightStream(node, handlers) {
+    const flightStream = renderRsc({
+        element: node
+    });
+    return new ReplayableStream(handlers ? wrapReadableStream(flightStream, handlers) : flightStream);
+}
+async function renderServerComponent(node) {
+    const stream = toReplayableFlightStream(/*#__PURE__*/ jsx(Fragment, {
+        children: node
+    }));
+    const streamWrapper = {
+        createReplayStream: ()=>stream.createReplayStream()
+    };
+    return createRscProxy(createTreeGetter(streamWrapper), {
+        renderable: true,
+        stream: streamWrapper
+    });
+}
+async function createCompositeComponent(component) {
+    const slotUsagesEmitter = 'development' === process.env.NODE_ENV ? createReadableStreamEmitter() : void 0;
+    const slotProxy = createSlotProxy({
+        onSlotCall: slotUsagesEmitter ? (slot, args)=>{
+            const sanitizedArgs = sanitizeSlotArgs(args);
+            slotUsagesEmitter.emit({
+                slot,
+                ...sanitizedArgs.length ? {
+                    args: sanitizedArgs
+                } : {}
+            });
+        } : void 0
+    });
+    async function ServerComponentWrapper() {
+        return component(slotProxy);
+    }
+    const flightStream = toReplayableFlightStream(/*#__PURE__*/ createElement(ServerComponentWrapper), slotUsagesEmitter ? {
+        onCancel: slotUsagesEmitter.close,
+        onDone: slotUsagesEmitter.close,
+        onError: slotUsagesEmitter.close
+    } : void 0);
+    const streamWrapper = {
+        createReplayStream: ()=>flightStream.createReplayStream()
+    };
+    return createRscProxy(createTreeGetter(streamWrapper), {
+        renderable: false,
+        slotUsagesStream: slotUsagesEmitter?.stream,
+        stream: streamWrapper
+    });
+}
+const adapter = createSerializationAdapter({
+    key: '$MODERN_TANSTACK_RSC',
+    test: isServerComponent,
+    toSerializable: (component)=>{
+        const streamWrapper = component[SERVER_COMPONENT_STREAM];
+        if (!streamWrapper) throw new Error('Cannot serialize TanStack RSC without a Flight stream.');
+        const kind = isRenderableServerComponent(component) ? 'renderable' : 'composite';
+        const slotUsagesStream = 'development' === process.env.NODE_ENV && 'composite' === kind ? component[RSC_SLOT_USAGES_STREAM] : void 0;
+        return {
+            kind,
+            stream: new RawStream(streamWrapper.createReplayStream(), {
+                hint: 'text'
+            }),
+            ...slotUsagesStream ? {
+                slotUsagesStream
+            } : {}
+        };
+    },
+    fromSerializable: ()=>{
+        throw new Error('TanStack RSC data should not be deserialized on server.');
+    }
+});
+function getTanstackRscSerializationAdapters() {
+    return [
+        adapter
+    ];
+}
+const rscSerializationAdapter = getTanstackRscSerializationAdapters;
+function createReadableStreamEmitter() {
+    let closed = false;
+    const queue = [];
+    let controller = null;
+    const stream = new ReadableStream({
+        start (ctrl) {
+            controller = ctrl;
+            for (const value of queue)ctrl.enqueue(value);
+            queue.length = 0;
+            if (closed) ctrl.close();
+        },
+        cancel () {
+            closed = true;
+            controller = null;
+            queue.length = 0;
+        }
+    });
+    const emit = (value)=>{
+        if (closed) return;
+        if (!controller) return void queue.push(value);
+        try {
+            controller.enqueue(value);
+        } catch  {}
+    };
+    const close = ()=>{
+        if (closed) return;
+        closed = true;
+        try {
+            controller?.close();
+        } catch  {}
+        controller = null;
+    };
+    return {
+        close,
+        emit,
+        stream
+    };
+}
+function wrapReadableStream(source, handlers) {
+    const reader = source.getReader();
+    let finished = false;
+    const finish = (kind)=>{
+        if (finished) return;
+        finished = true;
+        if ('cancel' === kind) handlers.onCancel?.();
+        else if ('error' === kind) handlers.onError?.();
+        else handlers.onDone?.();
+        try {
+            reader.releaseLock();
+        } catch  {}
+    };
+    return new ReadableStream({
+        async pull (controller) {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    controller.close();
+                    finish('done');
+                    return;
+                }
+                controller.enqueue(value);
+            } catch (err) {
+                try {
+                    controller.error(err);
+                } catch  {}
+                finish('error');
+            }
+        },
+        async cancel (reason) {
+            try {
+                await reader.cancel(reason);
+            } catch  {}
+            finish('cancel');
+        }
+    });
+}
+export { CompositeComponent } from "./CompositeComponent.mjs";
+export { createCompositeComponent, getTanstackRscSerializationAdapters, renderServerComponent, rscSerializationAdapter };

package/dist/esm-node/router/runtime/tanstack/rsc/slotUsageSanitizer.mjs

@@ -0,0 +1,32 @@
+import "node:module";
+import { isValidElement } from "react";
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_TRANSITIONAL_ELEMENT_TYPE = Symbol.for('react.transitional.element');
+function isReactElementLike(value) {
+    if (!value || 'object' != typeof value && 'function' != typeof value) return false;
+    if (isValidElement(value)) return true;
+    const type = value.$$typeof;
+    return type === REACT_ELEMENT_TYPE || type === REACT_TRANSITIONAL_ELEMENT_TYPE || type === REACT_PORTAL_TYPE;
+}
+function sanitizeSlotArg(value, seen) {
+    if (isReactElementLike(value)) return 'React element';
+    if (null == value) return value;
+    if ('string' == typeof value || 'number' == typeof value || 'boolean' == typeof value || 'bigint' == typeof value) return value;
+    if ('object' != typeof value && 'function' != typeof value) return String(value);
+    if (seen.has(value)) return '[Circular]';
+    seen.add(value);
+    if (Array.isArray(value)) return value.map((item)=>sanitizeSlotArg(item, seen));
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || null === proto) {
+        const out = {};
+        for (const [key, item] of Object.entries(value))out[key] = sanitizeSlotArg(item, seen);
+        return out;
+    }
+    return String(value);
+}
+function sanitizeSlotArgs(args) {
+    const seen = new WeakSet();
+    return args.map((arg)=>sanitizeSlotArg(arg, seen));
+}
+export { sanitizeSlotArgs };

package/dist/esm-node/router/runtime/tanstack/rsc/symbols.mjs

@@ -0,0 +1,18 @@
+import "node:module";
+const SERVER_COMPONENT_STREAM = Symbol.for('modern.tanstack.rsc.stream');
+const RENDERABLE_RSC = Symbol.for('modern.tanstack.rsc.renderable');
+const RSC_PROXY_GET_TREE = Symbol.for('modern.tanstack.rsc.proxy.getTree');
+const RSC_PROXY_PATH = Symbol.for('modern.tanstack.rsc.proxy.path');
+const RSC_SLOT_USAGES_STREAM = Symbol.for('modern.tanstack.rsc.slotUsages.stream');
+const RSC_SLOT_USAGES = Symbol.for('modern.tanstack.rsc.slotUsages');
+function isServerComponent(value) {
+    if (null == value) return false;
+    if ('object' != typeof value && 'function' != typeof value) return false;
+    return SERVER_COMPONENT_STREAM in value && void 0 !== value[SERVER_COMPONENT_STREAM];
+}
+function isRenderableServerComponent(value) {
+    if (null == value) return false;
+    if ('object' != typeof value && 'function' != typeof value) return false;
+    return RENDERABLE_RSC in value && true === value[RENDERABLE_RSC];
+}
+export { RENDERABLE_RSC, RSC_PROXY_GET_TREE, RSC_PROXY_PATH, RSC_SLOT_USAGES, RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM, isRenderableServerComponent, isServerComponent };

package/dist/esm-node/router/runtime/types.mjs

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

package/dist/esm-node/router/runtime/utils.mjs

@@ -0,0 +1,175 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { renderNestedRoute } from "@modern-js/runtime-utils/browser";
+import { Route, UNSAFE_ErrorResponseImpl, isRouteErrorResponse } from "@modern-js/runtime-utils/router";
+import react from "react";
+import { DefaultNotFound } from "./DefaultNotFound.mjs";
+import DeferredDataScripts from "./DeferredDataScripts.mjs";
+function getRouteComponents(routes, { globalApp, ssrMode, props }) {
+    const Layout = ({ Component, ...props })=>{
+        const GlobalLayout = globalApp;
+        if (!GlobalLayout) return /*#__PURE__*/ jsx(Component, {
+            ...props
+        });
+        return /*#__PURE__*/ jsx(GlobalLayout, {
+            Component: Component,
+            ...props
+        });
+    };
+    const routeElements = [];
+    for (const route of routes)if ('nested' === route.type) {
+        const routeElement = renderNestedRoute(route, {
+            DeferredDataComponent: 'stream' === ssrMode ? DeferredDataScripts : void 0,
+            props
+        });
+        routeElements.push(routeElement);
+    } else {
+        const routeElement = /*#__PURE__*/ jsx(Route, {
+            path: route.path,
+            element: /*#__PURE__*/ jsx(Layout, {
+                Component: route.component
+            })
+        }, route.path);
+        routeElements.push(routeElement);
+    }
+    routeElements.push(/*#__PURE__*/ jsx(Route, {
+        path: "*",
+        element: /*#__PURE__*/ jsx(DefaultNotFound, {}),
+        loader: ()=>new Response('404', {
+                status: 404
+            })
+    }, "*"));
+    return routeElements;
+}
+function getRouteObjects(routes, { globalApp, ssrMode, props }) {
+    const createLayoutElement = (Component)=>{
+        const GlobalLayout = globalApp;
+        if (!GlobalLayout) return Component;
+        const LayoutWrapper = (props)=>{
+            const LayoutComponent = GlobalLayout;
+            return /*#__PURE__*/ jsx(LayoutComponent, {
+                Component: Component,
+                ...props
+            });
+        };
+        return LayoutWrapper;
+    };
+    const routeObjects = [];
+    for (const route of routes)if ('nested' === route.type) {
+        const nestedRouteObject = {
+            path: route.path,
+            id: route.id,
+            loader: route.loader,
+            action: route.action,
+            hasErrorBoundary: route.hasErrorBoundary,
+            shouldRevalidate: route.shouldRevalidate,
+            handle: {
+                ...route.handle,
+                ...'object' == typeof route.config ? route.config?.handle : {}
+            },
+            index: route.index,
+            hasLoader: !!route.loader,
+            hasClientLoader: !!route.clientData,
+            hasAction: !!route.action,
+            ...route.isClientComponent ? {
+                isClientComponent: true
+            } : {},
+            ...route.inValidSSRRoute ? {
+                inValidSSRRoute: true
+            } : {},
+            lazyImport: route.lazyImport,
+            Component: route.component ? route.component : void 0,
+            errorElement: route.error ? /*#__PURE__*/ jsx(route.error, {}) : void 0,
+            children: route.children ? route.children.map((child)=>getRouteObjects([
+                    child
+                ], {
+                    globalApp,
+                    ssrMode,
+                    props
+                })[0]) : void 0
+        };
+        routeObjects.push(nestedRouteObject);
+    } else if ('function' == typeof route.component || 'object' == typeof route.component) {
+        const LayoutComponent = createLayoutElement(route.component);
+        const routeObject = {
+            path: route.path,
+            element: /*#__PURE__*/ react.createElement(LayoutComponent)
+        };
+        routeObjects.push(routeObject);
+    }
+    routeObjects.push({
+        path: '*',
+        element: /*#__PURE__*/ jsx(DefaultNotFound, {})
+    });
+    return routeObjects;
+}
+function createRouteObjectsFromConfig({ routesConfig, props, ssrMode }) {
+    if (!routesConfig) return null;
+    const { routes, globalApp } = routesConfig;
+    if (!routes) return null;
+    return getRouteObjects(routes, {
+        globalApp,
+        ssrMode,
+        props
+    });
+}
+function renderRoutes({ routesConfig, props, ssrMode }) {
+    if (!routesConfig) return null;
+    const { routes, globalApp } = routesConfig;
+    if (!routes) return null;
+    const routeElements = getRouteComponents(routes, {
+        globalApp,
+        ssrMode,
+        props
+    });
+    return routeElements;
+}
+function getLocation(serverContext) {
+    const { pathname = '', url = '' } = serverContext?.request || {};
+    const cleanUrl = url?.replace('http://', '')?.replace('https://', '');
+    const index = (cleanUrl || '').indexOf(pathname);
+    if (-1 === index) return pathname;
+    return cleanUrl.substring(index);
+}
+const urlJoin = (...parts)=>{
+    const separator = '/';
+    const replace = new RegExp(`${separator}{1,}`, 'g');
+    return standardSlash(parts.join(separator).replace(replace, separator));
+};
+function standardSlash(str) {
+    let addr = str;
+    if (!addr || 'string' != typeof addr) return addr;
+    if (addr.startsWith('.')) addr = addr.slice(1);
+    if (!addr.startsWith('/')) addr = `/${addr}`;
+    if (addr.endsWith('/') && '/' !== addr) addr = addr.slice(0, addr.length - 1);
+    return addr;
+}
+function serializeErrors(errors) {
+    if (!errors) return null;
+    const entries = Object.entries(errors);
+    const serialized = {};
+    for (const [key, val] of entries)if (isRouteErrorResponse(val)) serialized[key] = {
+        ...val,
+        __type: 'RouteErrorResponse'
+    };
+    else if (val instanceof Error) serialized[key] = {
+        message: val.message,
+        stack: val.stack,
+        __type: 'Error'
+    };
+    else serialized[key] = val;
+    return serialized;
+}
+function deserializeErrors(errors) {
+    if (!errors) return null;
+    const entries = Object.entries(errors);
+    const serialized = {};
+    for (const [key, val] of entries)if (val && 'RouteErrorResponse' === val.__type) serialized[key] = new UNSAFE_ErrorResponseImpl(val.status, val.statusText, val.data, true === val.internal);
+    else if (val && 'Error' === val.__type) {
+        const error = new Error(val.message);
+        error.stack = val.stack;
+        serialized[key] = error;
+    } else serialized[key] = val;
+    return serialized;
+}
+export { createRouteObjectsFromConfig, deserializeErrors, getLocation, getRouteComponents, getRouteObjects, renderRoutes, serializeErrors, standardSlash, urlJoin };

package/dist/esm-node/router/runtime/withRouter.mjs

@@ -0,0 +1,15 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { useLocation, useNavigate, useParams } from "@modern-js/runtime-utils/router";
+const withRouter = (Component)=>(props)=>{
+        const location = useLocation();
+        const params = useParams();
+        const navigate = useNavigate();
+        return /*#__PURE__*/ jsx(Component, {
+            ...props,
+            location: location,
+            params: params,
+            navigate: navigate
+        });
+    };
+export { withRouter };

package/dist/esm-node/rsc/client.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export * from "@modern-js/render/client";
+const isRedirectResponse = (res)=>null != res.headers.get('X-Modernjs-Redirect');
+export { isRedirectResponse };

package/dist/esm-node/rsc/server.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "@modern-js/render/rsc";

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

@@ -0,0 +1,45 @@
+import "node:module";
+import serverRender from "./serverRender";
+import { createSSRTracker } from "./serverRender/tracker";
+import { formatServer } from "./utils";
+export * from "./react";
+const ssr = (config = {})=>({
+        name: '@modern-js/plugin-ssr',
+        setup: ()=>({
+                server: async ({ App, context })=>{
+                    const html = await serverRender({
+                        context,
+                        App: App,
+                        config
+                    });
+                    return html;
+                },
+                init ({ context }, next) {
+                    const { request } = context.ssrContext;
+                    context.ssrContext.request = formatServer(request);
+                    context.ssrContext.mode = config.mode;
+                    context.ssrContext.tracker = createSSRTracker(context.ssrContext);
+                    context.ssrContext.unsafeHeaders = config.unsafeHeaders;
+                    if (!context.ssrContext.htmlModifiers) context.ssrContext.htmlModifiers = [];
+                    return next({
+                        context
+                    });
+                },
+                pickContext: ({ context, pickedContext }, next)=>{
+                    const { request, response } = context?.ssrContext;
+                    const { initialData } = context;
+                    return next({
+                        context,
+                        pickedContext: {
+                            ...pickedContext,
+                            initialData,
+                            request,
+                            response
+                        }
+                    });
+                }
+            })
+    });
+const index_node = ssr;
+export default index_node;
+export { ssr };