@modern-js/runtime 2.32.0 → 2.32.2-alpha.1

package/dist/esm/ssr/serverRender/renderToString/loadable.js

@@ -1,3 +1,6 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { ChunkExtractor } from "@loadable/server";
 import { attributesToString, getLoadableScripts } from "../utils";
 var extname = function(uri) {
@@ -7,64 +10,91 @@ var extname = function(uri) {
   }
   return ".".concat((_uri = uri) === null || _uri === void 0 ? void 0 : _uri.split(".").pop()) || "";
 };
-export var toHtml = function(jsx, renderer, next) {
-  var stats = renderer.stats, chunksMap = renderer.result.chunksMap, _renderer_config = renderer.config, config = _renderer_config === void 0 ? {} : _renderer_config, nonce = renderer.nonce;
-  if (!stats || chunksMap.js) {
-    return next(jsx);
+var LoadableCollector = /* @__PURE__ */ function() {
+  "use strict";
+  function LoadableCollector2(options) {
+    _class_call_check(this, LoadableCollector2);
+    _define_property(this, "options", void 0);
+    _define_property(this, "extractor", void 0);
+    this.options = options;
   }
-  var extractor = new ChunkExtractor({
-    stats: stats,
-    entrypoints: [
-      renderer.entryName
-    ]
-  });
-  var html = next(extractor.collectChunks(jsx));
-  var chunks = extractor.getChunkAssets(extractor.chunks);
-  chunksMap.js = (chunksMap.js || "") + getLoadableScripts(extractor);
-  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-  try {
-    for (var _iterator = chunks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-      var v = _step.value;
-      var fileType = extname(v.url).slice(1);
-      var attributes = {};
-      var crossorigin = config.crossorigin, _config_scriptLoading = config.scriptLoading, scriptLoading = _config_scriptLoading === void 0 ? "defer" : _config_scriptLoading;
-      if (crossorigin) {
-        attributes.crossorigin = crossorigin === true ? "anonymous" : crossorigin;
-      }
-      switch (scriptLoading) {
-        case "defer":
-          attributes.defer = true;
-          break;
-        case "module":
-          attributes.type = "module";
-          break;
-        default:
-      }
-      if (fileType === "js") {
-        var jsChunkReg = new RegExp('<script .*src="'.concat(v.url, '".*>'));
-        if (!jsChunkReg.test(renderer.template)) {
-          attributes.nonce = nonce;
-          var attrsStr = attributesToString(attributes);
-          chunksMap[fileType] += "<script".concat(attrsStr, ' src="').concat(v.url, '"></script>');
+  _create_class(LoadableCollector2, [
+    {
+      key: "collect",
+      value: function collect(comopnent) {
+        var _this_options = this.options, stats = _this_options.stats, entryName = _this_options.entryName;
+        if (!stats) {
+          return comopnent;
         }
-      } else if (fileType === "css") {
-        var attrsStr1 = attributesToString(attributes);
-        chunksMap[fileType] += "<link".concat(attrsStr1, ' href="').concat(v.url, '" rel="stylesheet" />');
-      }
-    }
-  } catch (err) {
-    _didIteratorError = true;
-    _iteratorError = err;
-  } finally {
-    try {
-      if (!_iteratorNormalCompletion && _iterator.return != null) {
-        _iterator.return();
+        this.extractor = new ChunkExtractor({
+          stats: stats,
+          entrypoints: [
+            entryName
+          ]
+        });
+        return this.extractor.collectChunks(comopnent);
       }
-    } finally {
-      if (_didIteratorError) {
-        throw _iteratorError;
+    },
+    {
+      key: "effect",
+      value: function effect() {
+        if (!this.extractor) {
+          return;
+        }
+        var _this_options = this.options, chunksMap = _this_options.result.chunksMap, config = _this_options.config, template = _this_options.template, nonce = _this_options.nonce;
+        var extractor = this.extractor;
+        var chunks = extractor.getChunkAssets(extractor.chunks);
+        chunksMap.js = (chunksMap.js || "") + getLoadableScripts(extractor);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+          for (var _iterator = chunks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var v = _step.value;
+            var fileType = extname(v.url).slice(1);
+            var attributes = {};
+            var crossorigin = config.crossorigin, _config_scriptLoading = config.scriptLoading, scriptLoading = _config_scriptLoading === void 0 ? "defer" : _config_scriptLoading;
+            if (crossorigin) {
+              attributes.crossorigin = crossorigin === true ? "anonymous" : crossorigin;
+            }
+            switch (scriptLoading) {
+              case "defer":
+                attributes.defer = true;
+                break;
+              case "module":
+                attributes.type = "module";
+                break;
+              default:
+            }
+            if (fileType === "js") {
+              var jsChunkReg = new RegExp('<script .*src="'.concat(v.url, '".*>'));
+              if (!jsChunkReg.test(template)) {
+                attributes.nonce = nonce;
+                var attrsStr = attributesToString(attributes);
+                chunksMap[fileType] += "<script".concat(attrsStr, ' src="').concat(v.url, '"></script>');
+              }
+            } else if (fileType === "css") {
+              var attrsStr1 = attributesToString(attributes);
+              chunksMap[fileType] += "<link".concat(attrsStr1, ' href="').concat(v.url, '" rel="stylesheet" />');
+            }
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
       }
     }
-  }
-  return html;
-};
+  ]);
+  return LoadableCollector2;
+}();
+export function createLoadableCollector(options) {
+  return new LoadableCollector(options);
+}

package/dist/esm/ssr/serverRender/renderToString/render.js

@@ -0,0 +1,39 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import ReactDomServer from "react-dom/server";
+var Render = /* @__PURE__ */ function() {
+  "use strict";
+  function Render2(App) {
+    _class_call_check(this, Render2);
+    _define_property(this, "App", void 0);
+    _define_property(this, "collectors", []);
+    this.App = App;
+  }
+  _create_class(Render2, [
+    {
+      key: "addCollector",
+      value: function addCollector(collector) {
+        this.collectors.push(collector);
+        return this;
+      }
+    },
+    {
+      key: "finish",
+      value: function finish() {
+        var App = this.collectors.reduce(function(pre, collector) {
+          return collector.collect(pre);
+        }, this.App);
+        var html = ReactDomServer.renderToString(App);
+        this.collectors.forEach(function(component) {
+          component.effect();
+        });
+        return html;
+      }
+    }
+  ]);
+  return Render2;
+}();
+export function createRender(App) {
+  return new Render(App);
+}

package/dist/esm/ssr/serverRender/renderToString/styledComponent.js

@@ -1,8 +1,32 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { ServerStyleSheet } from "styled-components";
-export var toHtml = function(jsx, renderer, next) {
-  var sheet = new ServerStyleSheet();
-  var html = next(sheet.collectStyles(jsx));
-  var css = sheet.getStyleTags();
-  renderer.result.chunksMap.css += css;
-  return html;
-};
+var StyledCollector = /* @__PURE__ */ function() {
+  "use strict";
+  function StyledCollector2(result) {
+    _class_call_check(this, StyledCollector2);
+    _define_property(this, "sheet", new ServerStyleSheet());
+    _define_property(this, "result", void 0);
+    this.result = result;
+  }
+  _create_class(StyledCollector2, [
+    {
+      key: "collect",
+      value: function collect(comopnent) {
+        return this.sheet.collectStyles(comopnent);
+      }
+    },
+    {
+      key: "effect",
+      value: function effect() {
+        var css = this.sheet.getStyleTags();
+        this.result.chunksMap.css += css;
+      }
+    }
+  ]);
+  return StyledCollector2;
+}();
+export function createStyledCollector(result) {
+  return new StyledCollector(result);
+}

package/dist/esm-node/document/cli/index.js

@@ -115,12 +115,17 @@ export const documentPlugin = () => ({
           htmlWebpackPlugin.tags.headTags.filter((item) => item.tagName === "script").join(""),
           htmlWebpackPlugin.tags.bodyTags.toString()
         ].join("");
+        const partialsContent = {
+          partialsTop: "",
+          partialsHead: "",
+          partialsBody: ""
+        };
         if ((_partialsByEntrypoint = partialsByEntrypoint) === null || _partialsByEntrypoint === void 0 ? void 0 : _partialsByEntrypoint[entryName]) {
-          const partialsTop = partialsByEntrypoint[entryName].top.join("\n");
-          const partialsHead = partialsByEntrypoint[entryName].head.join("\n");
-          const partialsBody = partialsByEntrypoint[entryName].body.join("\n");
-          html = html.replace(TOP_PARTICALS_SEPARATOR, partialsTop).replace(HEAD_PARTICALS_SEPARATOR, partialsHead).replace(BODY_PARTICALS_SEPARATOR, partialsBody);
+          partialsContent.partialsTop = partialsByEntrypoint[entryName].top.join("\n");
+          partialsContent.partialsHead = partialsByEntrypoint[entryName].head.join("\n");
+          partialsContent.partialsBody = partialsByEntrypoint[entryName].body.join("\n");
         }
+        html = html.replace(TOP_PARTICALS_SEPARATOR, partialsContent.partialsTop).replace(HEAD_PARTICALS_SEPARATOR, partialsContent.partialsHead).replace(BODY_PARTICALS_SEPARATOR, partialsContent.partialsBody);
         const links = [
           htmlWebpackPlugin.tags.headTags.filter((item) => item.tagName === "link").join("")
         ].join("");

package/dist/esm-node/ssr/cli/loadable-bundler-plugin.js

@@ -71,7 +71,7 @@ class LoadablePlugin {
     const outputFile = path.resolve(outputFolder || "", this.opts.filename);
     fs.outputFileSync(outputFile, manifest);
   }
-  constructor({ filename = "loadable-stats.json", path: path1, writeToDisk, outputAsset = true, chunkLoadingGlobal = "__LOADABLE_LOADED_CHUNKS__" } = {
+  constructor({ filename = "loadable-stats.json", path: path2, writeToDisk, outputAsset = true, chunkLoadingGlobal = "__LOADABLE_LOADED_CHUNKS__" } = {
     filename: "loadable-stats.json",
     outputAsset: true,
     chunkLoadingGlobal: "__LOADABLE_LOADED_CHUNKS__"
@@ -80,7 +80,7 @@ class LoadablePlugin {
     _define_property(this, "compiler", void 0);
     this.opts = {
       filename,
-      path: path1,
+      path: path2,
       writeToDisk,
       outputAsset,
       chunkLoadingGlobal

package/dist/esm-node/ssr/serverRender/renderToString/buildHtml.js

@@ -0,0 +1,19 @@
+export function buildHtml(template, callbacks) {
+  return callbacks.reduce((tmp, cb) => cb(tmp), template);
+}
+export function createReplaceHtml(html) {
+  const HTML_REG = /<!--<\?-\s*html\s*\?>-->/;
+  return (template) => template.replace(HTML_REG, html);
+}
+export function createReplaceSSRDataScript(data) {
+  const SSR_DATA_REG = /<!--<\?-\s*SSRDataScript\s*\?>-->/;
+  return (template) => template.replace(SSR_DATA_REG, data);
+}
+export function createReplaceChunkJs(js) {
+  const CHUNK_JS_REG = /<!--<\?-\s*chunksMap\.js\s*\?>-->/;
+  return (template) => template.replace(CHUNK_JS_REG, js);
+}
+export function createReplaceChunkCss(css) {
+  const CHUNK_CSS_REG = /<!--<\?-\s*chunksMap\.css\s*\?>-->/;
+  return (template) => template.replace(CHUNK_CSS_REG, css);
+}

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

@@ -1,6 +1,5 @@
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import React from "react";
-import ReactDomServer from "react-dom/server";
 import { serializeJson } from "@modern-js/utils/runtime-node";
 import ReactHelmet from "react-helmet";
 import { time } from "@modern-js/utils/universal/time";
@@ -10,10 +9,10 @@ import { RenderLevel } from "../types";
 import prefetch from "../../prefetch";
 import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID, attributesToString } from "../utils";
 import { SSRErrors, SSRTimings, createSSRTracker } from "../tracker";
-import { toFragments } from "./template";
-import { reduce } from "./reduce";
-import * as loadableRenderer from "./loadable";
-import * as styledComponentRenderer from "./styledComponent";
+import { createLoadableCollector } from "./loadable";
+import { createRender } from "./render";
+import { createStyledCollector } from "./styledComponent";
+import { buildHtml, createReplaceChunkCss, createReplaceChunkJs, createReplaceHtml, createReplaceSSRDataScript } from "./buildHtml";
 const buildTemplateData = (context, data, renderLevel, tracker) => {
   const { request, enableUnsafeCtx } = context;
   const unsafeContext = {
@@ -59,16 +58,14 @@ class Entry {
       loaderData: routerContext.loaderData,
       errors: serializeErrors(routerContext.errors)
     } : void 0;
-    let html = "";
     const templateData = buildTemplateData(ssrContext, prefetchData, this.result.renderLevel, this.tracker);
-    const SSRData = this.getSSRDataScript(templateData, routerData);
-    for (const fragment of this.fragments) {
-      if (fragment.isVariable && fragment.content === "SSRDataScript") {
-        html += fragment.getValue(SSRData);
-      } else {
-        html += fragment.getValue(this.result);
-      }
-    }
+    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)
+    ]);
     const helmetData = ReactHelmet.renderStatic();
     return helmetData ? helmetReplace(html, helmetData) : html;
   }
@@ -96,20 +93,14 @@ class Entry {
           ssr: true
         })
       });
-      const renderContext = {
+      html = createRender(App).addCollector(createStyledCollector(this.result)).addCollector(createLoadableCollector({
         stats: ssrContext.loadableStats,
-        host: this.host,
         result: this.result,
         entryName: this.entryName,
         config: this.pluginConfig,
         nonce: this.nonce,
         template: this.template
-      };
-      html = reduce(App, renderContext, [
-        styledComponentRenderer.toHtml,
-        loadableRenderer.toHtml,
-        (jsx) => ReactDomServer.renderToString(jsx)
-      ]);
+      })).finish();
       const cost = end();
       this.tracker.trackTiming(SSRTimings.SSR_RENDER_HTML, cost);
       this.result.renderLevel = RenderLevel.SERVER_RENDER;
@@ -131,9 +122,7 @@ class Entry {
 <script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>` : `
 <script type="application/json" id="${ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>`;
     }
-    return {
-      SSRDataScript: ssrDataScripts
-    };
+    return ssrDataScripts;
   }
   constructor(options) {
     _define_property(this, "entryName", void 0);
@@ -142,13 +131,11 @@ class Entry {
     _define_property(this, "tracker", void 0);
     _define_property(this, "template", void 0);
     _define_property(this, "App", void 0);
-    _define_property(this, "fragments", void 0);
     _define_property(this, "pluginConfig", void 0);
     _define_property(this, "host", void 0);
     _define_property(this, "nonce", void 0);
     const { ctx, config } = options;
     const { entryName, template, request: { host }, nonce } = ctx;
-    this.fragments = toFragments(template, entryName);
     this.template = template;
     this.entryName = entryName;
     this.host = host;

package/dist/esm-node/ssr/serverRender/renderToString/loadable.js

@@ -1,3 +1,4 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { ChunkExtractor } from "@loadable/server";
 import { attributesToString, getLoadableScripts } from "../utils";
 const extname = (uri) => {
@@ -7,47 +8,63 @@ const extname = (uri) => {
   }
   return `.${(_uri = uri) === null || _uri === void 0 ? void 0 : _uri.split(".").pop()}` || "";
 };
-export const toHtml = (jsx, renderer, next) => {
-  const { stats, result: { chunksMap }, config = {}, nonce } = renderer;
-  if (!stats || chunksMap.js) {
-    return next(jsx);
-  }
-  const extractor = new ChunkExtractor({
-    stats,
-    entrypoints: [
-      renderer.entryName
-    ]
-  });
-  const html = next(extractor.collectChunks(jsx));
-  const chunks = extractor.getChunkAssets(extractor.chunks);
-  chunksMap.js = (chunksMap.js || "") + getLoadableScripts(extractor);
-  for (const v of chunks) {
-    const fileType = extname(v.url).slice(1);
-    const attributes = {};
-    const { crossorigin, scriptLoading = "defer" } = config;
-    if (crossorigin) {
-      attributes.crossorigin = crossorigin === true ? "anonymous" : crossorigin;
+class LoadableCollector {
+  collect(comopnent) {
+    const { stats, entryName } = this.options;
+    if (!stats) {
+      return comopnent;
     }
-    switch (scriptLoading) {
-      case "defer":
-        attributes.defer = true;
-        break;
-      case "module":
-        attributes.type = "module";
-        break;
-      default:
+    this.extractor = new ChunkExtractor({
+      stats,
+      entrypoints: [
+        entryName
+      ]
+    });
+    return this.extractor.collectChunks(comopnent);
+  }
+  effect() {
+    if (!this.extractor) {
+      return;
     }
-    if (fileType === "js") {
-      const jsChunkReg = new RegExp(`<script .*src="${v.url}".*>`);
-      if (!jsChunkReg.test(renderer.template)) {
-        attributes.nonce = nonce;
+    const { result: { chunksMap }, config, template, nonce } = this.options;
+    const { extractor } = this;
+    const chunks = extractor.getChunkAssets(extractor.chunks);
+    chunksMap.js = (chunksMap.js || "") + getLoadableScripts(extractor);
+    for (const v of chunks) {
+      const fileType = extname(v.url).slice(1);
+      const attributes = {};
+      const { crossorigin, scriptLoading = "defer" } = config;
+      if (crossorigin) {
+        attributes.crossorigin = crossorigin === true ? "anonymous" : crossorigin;
+      }
+      switch (scriptLoading) {
+        case "defer":
+          attributes.defer = true;
+          break;
+        case "module":
+          attributes.type = "module";
+          break;
+        default:
+      }
+      if (fileType === "js") {
+        const jsChunkReg = new RegExp(`<script .*src="${v.url}".*>`);
+        if (!jsChunkReg.test(template)) {
+          attributes.nonce = nonce;
+          const attrsStr = attributesToString(attributes);
+          chunksMap[fileType] += `<script${attrsStr} src="${v.url}"></script>`;
+        }
+      } else if (fileType === "css") {
         const attrsStr = attributesToString(attributes);
-        chunksMap[fileType] += `<script${attrsStr} src="${v.url}"></script>`;
+        chunksMap[fileType] += `<link${attrsStr} href="${v.url}" rel="stylesheet" />`;
       }
-    } else if (fileType === "css") {
-      const attrsStr = attributesToString(attributes);
-      chunksMap[fileType] += `<link${attrsStr} href="${v.url}" rel="stylesheet" />`;
     }
   }
-  return html;
-};
+  constructor(options) {
+    _define_property(this, "options", void 0);
+    _define_property(this, "extractor", void 0);
+    this.options = options;
+  }
+}
+export function createLoadableCollector(options) {
+  return new LoadableCollector(options);
+}

package/dist/esm-node/ssr/serverRender/renderToString/render.js

@@ -0,0 +1,24 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import ReactDomServer from "react-dom/server";
+class Render {
+  addCollector(collector) {
+    this.collectors.push(collector);
+    return this;
+  }
+  finish() {
+    const App = this.collectors.reduce((pre, collector) => collector.collect(pre), this.App);
+    const html = ReactDomServer.renderToString(App);
+    this.collectors.forEach((component) => {
+      component.effect();
+    });
+    return html;
+  }
+  constructor(App) {
+    _define_property(this, "App", void 0);
+    _define_property(this, "collectors", []);
+    this.App = App;
+  }
+}
+export function createRender(App) {
+  return new Render(App);
+}

package/dist/esm-node/ssr/serverRender/renderToString/styledComponent.js

@@ -1,8 +1,19 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { ServerStyleSheet } from "styled-components";
-export const toHtml = (jsx, renderer, next) => {
-  const sheet = new ServerStyleSheet();
-  const html = next(sheet.collectStyles(jsx));
-  const css = sheet.getStyleTags();
-  renderer.result.chunksMap.css += css;
-  return html;
-};
+class StyledCollector {
+  collect(comopnent) {
+    return this.sheet.collectStyles(comopnent);
+  }
+  effect() {
+    const css = this.sheet.getStyleTags();
+    this.result.chunksMap.css += css;
+  }
+  constructor(result) {
+    _define_property(this, "sheet", new ServerStyleSheet());
+    _define_property(this, "result", void 0);
+    this.result = result;
+  }
+}
+export function createStyledCollector(result) {
+  return new StyledCollector(result);
+}

package/dist/types/ssr/serverRender/renderToStream/template.d.ts

@@ -1,3 +1,6 @@
 import { RenderLevel, RuntimeContext } from '../types';
-import { InjectTemplate } from './type';
+export type InjectTemplate = {
+  shellBefore: string;
+  shellAfter: string;
+};
 export declare const getTemplates: (context: RuntimeContext, renderLevel: RenderLevel) => InjectTemplate;

package/dist/types/ssr/serverRender/renderToString/buildHtml.d.ts

@@ -0,0 +1,6 @@
+export type BuildHtmlCb = (tempalte: string) => string;
+export declare function buildHtml(template: string, callbacks: BuildHtmlCb[]): string;
+export declare function createReplaceHtml(html: string): BuildHtmlCb;
+export declare function createReplaceSSRDataScript(data: string): BuildHtmlCb;
+export declare function createReplaceChunkJs(js: string): BuildHtmlCb;
+export declare function createReplaceChunkCss(css: string): BuildHtmlCb;

package/dist/types/ssr/serverRender/renderToString/entry.d.ts

@@ -13,7 +13,6 @@ export default class Entry {
   tracker: SSRTracker;
   private readonly template;
   private readonly App;
-  private readonly fragments;
   private readonly pluginConfig;
   private readonly host;
   private readonly nonce?;

package/dist/types/ssr/serverRender/renderToString/loadable.d.ts

@@ -1,2 +1,21 @@
-import { RenderHandler } from './type';
-export declare const toHtml: RenderHandler;
+import { ReactElement } from 'react';
+import { SSRPluginConfig } from '../types';
+import { RenderResult } from './type';
+import type { Collector } from './render';
+declare class LoadableCollector implements Collector {
+  private options;
+  private extractor?;
+  constructor(options: LoadableCollectorOptions);
+  collect(comopnent: ReactElement): ReactElement;
+  effect(): void;
+}
+export interface LoadableCollectorOptions {
+  nonce?: string;
+  stats?: Record<string, any>;
+  template: string;
+  config: SSRPluginConfig;
+  entryName: string;
+  result: RenderResult;
+}
+export declare function createLoadableCollector(options: LoadableCollectorOptions): LoadableCollector;
+export {};

package/dist/types/ssr/serverRender/renderToString/render.d.ts

@@ -0,0 +1,14 @@
+import type { ReactElement } from 'react';
+export interface Collector {
+  collect: (comopnent: ReactElement) => ReactElement;
+  effect: () => void;
+}
+declare class Render {
+  private App;
+  private collectors;
+  constructor(App: ReactElement);
+  addCollector(collector: Collector): this;
+  finish(): string;
+}
+export declare function createRender(App: ReactElement): Render;
+export {};

package/dist/types/ssr/serverRender/renderToString/styledComponent.d.ts

@@ -1,2 +1,15 @@
-import { RenderHandler } from './type';
-export declare const toHtml: RenderHandler;
+import { ServerStyleSheet } from 'styled-components';
+import { ReactElement } from 'react';
+import type { RenderResult } from './type';
+import type { Collector } from './render';
+declare class StyledCollector implements Collector {
+  sheet: ServerStyleSheet;
+  result: RenderResult;
+  constructor(result: RenderResult);
+  collect(comopnent: ReactElement): ReactElement<{
+    sheet: ServerStyleSheet;
+  }, string | import("react").JSXElementConstructor<any>>;
+  effect(): void;
+}
+export declare function createStyledCollector(result: RenderResult): StyledCollector;
+export {};

package/dist/types/ssr/serverRender/renderToString/type.d.ts

@@ -1,6 +1,4 @@
-/// <reference types="react" />
 import type { BaseSSRServerContext } from '@modern-js/types';
-import type { SSRPluginConfig } from '../types';
 export declare enum RenderLevel {
   CLIENT_RENDER = 0,
   SERVER_PREFETCH = 1,
@@ -13,16 +11,6 @@ export type SSRServerContext = BaseSSRServerContext & {
     cookieMap: Record<string, string>;
   };
 };
-export interface RenderEntry {
-  entryName: string;
-  host: string;
-  result: RenderResult;
-  stats: Record<string, any>;
-  config: SSRPluginConfig;
-  template: string;
-  nonce?: string;
-}
-export type RenderHandler = (jsx: React.ReactElement, renderer: RenderEntry, next: (jsx: React.ReactElement) => string) => string;
 export type RenderResult = {
   renderLevel: RenderLevel;
   html?: string;