@bleedingdev/modern-js-runtime 3.2.0-ultramodern.99 → 3.4.0-ultramodern.1

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

@@ -1,54 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

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

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

@@ -1,201 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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/ssr/index.node.mjs

@@ -1,45 +0,0 @@
-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 };

package/dist/esm-node/ssr/serverRender/renderToStream/buildTemplate.after.mjs

@@ -1,51 +0,0 @@
-import "node:module";
-import { sanitizeSSRPayload, serializeJson } from "@modern-js/runtime-utils/node";
-import { attributesToString } from "../utils";
-import { buildTemplate } from "./buildTemplate.share";
-function buildShellAfterTemplate(afterAppTemplate, options) {
-    const callbacks = [
-        injectSSRDataScript
-    ];
-    return buildTemplate(afterAppTemplate, callbacks);
-    function injectSSRDataScript(template) {
-        const ssrDataScript = buildSSRDataScript();
-        return template.replace('<!--<?- SSRDataScript ?>-->', ssrDataScript);
-        function buildSSRDataScript() {
-            const { context: { ssrContext, initialData, __i18nData__ }, renderLevel } = options;
-            const { request, enableUnsafeCtx, nonce, tracker, unsafeHeaders } = ssrContext;
-            const unsafeContext = {
-                headers: request.headers
-            };
-            const SSRData = {
-                data: {
-                    initialData,
-                    i18nData: __i18nData__
-                },
-                context: {
-                    reporter: {
-                        sessionId: tracker.sessionId
-                    },
-                    request: {
-                        params: request.params,
-                        query: request.query,
-                        pathname: request.pathname,
-                        host: request.host,
-                        url: request.url,
-                        ...enableUnsafeCtx ? unsafeContext : {}
-                    }
-                },
-                renderLevel
-            };
-            const attrsStr = attributesToString({
-                nonce
-            });
-            const sanitizedSSRData = sanitizeSSRPayload(SSRData, {
-                unsafeHeaders
-            }).payload;
-            return `
-      <script${attrsStr}>window._SSR_DATA = ${serializeJson(sanitizedSSRData)}</script>
-      `;
-        }
-    }
-}
-export { buildShellAfterTemplate };

package/dist/esm-node/ssr/serverRender/renderToString/entry.mjs

@@ -1,152 +0,0 @@
-import "node:module";
-import { sanitizeSSRPayload, serializeJson } from "@modern-js/runtime-utils/node";
-import { time } from "@modern-js/runtime-utils/time";
-import react from "react";
-import { HelmetProvider } from "react-helmet-async";
-import { getHelmetData, helmetReplace } from "../../../core/server/helmet.mjs";
-import { serializeErrors } from "../../../router/runtime/utils.mjs";
-import prefetch from "../../prefetch";
-import { SSRErrors, SSRTimings } from "../tracker";
-import { RenderLevel } from "../types.mjs";
-import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID, attributesToString } from "../utils";
-import { buildHtml, createReplaceChunkCss, createReplaceChunkJs, createReplaceHtml, createReplaceSSRDataScript } from "./buildHtml";
-import { createLoadableCollector } from "./loadable";
-import { createRender } from "./render";
-import { createStyledCollector } from "./styledComponent";
-const buildTemplateData = (context, data, renderLevel, tracker)=>{
-    const { request, enableUnsafeCtx } = context;
-    const unsafeContext = {
-        headers: request.headers
-    };
-    return {
-        data,
-        context: {
-            request: {
-                params: request.params,
-                query: request.query,
-                pathname: request.pathname,
-                host: request.host,
-                url: request.url,
-                ...enableUnsafeCtx ? unsafeContext : {}
-            },
-            reporter: {
-                sessionId: tracker.sessionId
-            }
-        },
-        renderLevel
-    };
-};
-class Entry {
-    async renderToHtml(context) {
-        const ssrContext = context.ssrContext;
-        if (ssrContext.redirection?.url) return '';
-        const prefetchData = await this.prefetch(context);
-        if (ssrContext.redirection?.url) return '';
-        if (this.result.renderLevel >= RenderLevel.SERVER_PREFETCH) this.result.html = await this.renderToString(context);
-        if (ssrContext.redirection?.url) return '';
-        const { routerContext, routerServerSnapshot } = context;
-        const routerData = routerServerSnapshot?.routerData ? {
-            loaderData: routerServerSnapshot.routerData.loaderData,
-            errors: serializeErrors(routerServerSnapshot.routerData.errors)
-        } : routerContext ? {
-            loaderData: routerContext.loaderData,
-            errors: serializeErrors(routerContext.errors)
-        } : void 0;
-        const templateData = buildTemplateData(ssrContext, prefetchData, this.result.renderLevel, this.tracker);
-        const ssrDataScripts = this.getSSRDataScript(templateData, routerData);
-        const html = buildHtml(this.template, [
-            createReplaceChunkCss(this.result.chunksMap.css),
-            createReplaceChunkJs(this.result.chunksMap.js),
-            createReplaceHtml(this.result.html || ''),
-            createReplaceSSRDataScript(ssrDataScripts),
-            ...this.htmlModifiers
-        ]);
-        const helmetData = getHelmetData(context);
-        return helmetData ? helmetReplace(html, helmetData) : html;
-    }
-    async prefetch(context) {
-        let prefetchData;
-        const end = time();
-        try {
-            prefetchData = await prefetch(this.App, context, this.pluginConfig);
-            this.result.renderLevel = RenderLevel.SERVER_PREFETCH;
-            const prefetchCost = end();
-            this.tracker.trackTiming(SSRTimings.SSR_PREFETCH, prefetchCost);
-        } catch (e) {
-            this.result.renderLevel = RenderLevel.CLIENT_RENDER;
-            this.tracker.trackError(SSRErrors.PREFETCH, e);
-        }
-        return prefetchData || {};
-    }
-    async renderToString(context) {
-        let html = '';
-        const end = time();
-        const { ssrContext } = context;
-        try {
-            const helmetContext = context._helmetContext ??= {};
-            const App = react.createElement(HelmetProvider, {
-                context: helmetContext
-            }, react.createElement(this.App, {
-                context: Object.assign(context, {
-                    ssr: true
-                })
-            }));
-            html = await createRender(App).addCollector(createStyledCollector(this.result)).addCollector(createLoadableCollector({
-                stats: ssrContext.loadableStats,
-                result: this.result,
-                entryName: this.entryName,
-                config: this.pluginConfig,
-                nonce: this.nonce,
-                template: this.template,
-                routeManifest: this.routeManifest
-            })).finish();
-            const cost = end();
-            this.tracker.trackTiming(SSRTimings.SSR_RENDER_HTML, cost);
-            this.result.renderLevel = RenderLevel.SERVER_RENDER;
-        } catch (e) {
-            this.tracker.trackError(SSRErrors.RENDER_HTML, e);
-        }
-        return html;
-    }
-    getSSRDataScript(templateData, routerData) {
-        const useInlineScript = false !== this.pluginConfig.inlineScript;
-        const sanitizedTemplateData = sanitizeSSRPayload(templateData, {
-            unsafeHeaders: this.pluginConfig.unsafeHeaders
-        }).payload;
-        const ssrData = serializeJson(sanitizedTemplateData);
-        const attrsStr = attributesToString({
-            nonce: this.nonce
-        });
-        let ssrDataScripts = useInlineScript ? `<script${attrsStr}>window._SSR_DATA = ${ssrData}</script>` : `<script type="application/json" id="${SSR_DATA_JSON_ID}">${ssrData}</script>`;
-        if (routerData) {
-            const sanitizedRouterData = sanitizeSSRPayload(routerData, {
-                unsafeHeaders: this.pluginConfig.unsafeHeaders
-            }).payload;
-            const serializedRouterData = serializeJson(sanitizedRouterData);
-            ssrDataScripts += useInlineScript ? `\n<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>` : `\n<script type="application/json" id="${ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>`;
-        }
-        return ssrDataScripts;
-    }
-    constructor(options){
-        const { ctx, config } = options;
-        const { entryName, template, nonce } = ctx;
-        this.template = template;
-        this.entryName = entryName;
-        this.App = options.App;
-        this.pluginConfig = config;
-        this.routeManifest = ctx.routeManifest;
-        this.tracker = ctx.tracker;
-        this.metrics = ctx.metrics;
-        this.htmlModifiers = ctx.htmlModifiers;
-        this.nonce = nonce;
-        this.result = {
-            renderLevel: RenderLevel.CLIENT_RENDER,
-            html: '',
-            chunksMap: {
-                js: '',
-                css: ''
-            }
-        };
-    }
-}
-export default Entry;

package/dist/esm-node/ssr/serverRender/types.mjs

@@ -1,2 +0,0 @@
-import "node:module";
-export { RenderLevel } from "./renderToString/type";

package/dist/types/router/cli/code/tanstackTypes.d.ts

@@ -1,10 +0,0 @@
-import type { AppToolsContext } from '@modern-js/app-tools';
-import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
-export declare function isTanstackRouterFrameworkEnabled(appContext: AppToolsContext): Promise<boolean>;
-export declare function generateTanstackRouterTypesSourceForEntry(opts: {
-    appContext: AppToolsContext;
-    entryName: string;
-    routes: (NestedRouteForCli | PageRoute)[];
-}): Promise<{
-    routerGenTs: string;
-}>;