@modern-js/runtime 1.21.2 → 2.0.0-beta.0

package/dist/js/treeshaking/ssr/index.js

@@ -3,12 +3,11 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { loadableReady } from '@loadable/component';
 import hoistNonReactStatics from 'hoist-non-react-statics';
-import { RenderLevel } from "./serverRender/type";
+import { RenderLevel } from "./serverRender/types";
 import { WithCallback } from "./react/withCallback";
-import { formatClient, mockResponse } from "./utils";
+import { formatClient, mockResponse, isReact18 } from "./utils";
 import { jsx as _jsx } from "react/jsx-runtime";
-var IS_REACT18 = process.env.IS_REACT18 === 'true';
-export var ssr = function ssr(_) {
+export var ssr = function ssr(config) {
   return {
     name: '@modern-js/plugin-ssr',
     setup: function setup() {
@@ -16,60 +15,90 @@ export var ssr = function ssr(_) {
       return {
         client: function () {
           var _client = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
-            var _window, _window$_SSR_DATA;
-
-            var App, context, ModernRender, ModernHydrate, renderLevel;
+            var App, context, ModernRender, ModernHydrate, hydrateContext, callback, stringSSRHydrate, streamSSRHydrate;
             return _regeneratorRuntime().wrap(function _callee$(_context) {
               while (1) {
                 switch (_context.prev = _context.next) {
                   case 0:
-                    App = _ref.App, context = _ref.context, ModernRender = _ref.ModernRender, ModernHydrate = _ref.ModernHydrate;
-                    // if render level not exist, use client render
-                    renderLevel = ((_window = window) === null || _window === void 0 ? void 0 : (_window$_SSR_DATA = _window._SSR_DATA) === null || _window$_SSR_DATA === void 0 ? void 0 : _window$_SSR_DATA.renderLevel) || RenderLevel.CLIENT_RENDER; // client render and server prefetch use same logic
-
-                    if (renderLevel === RenderLevel.CLIENT_RENDER || renderLevel === RenderLevel.SERVER_PREFETCH) {
-                      ModernRender( /*#__PURE__*/_jsx(App, {
-                        context: context
-                      }));
-                    } else if (renderLevel === RenderLevel.SERVER_RENDER) {
-                      loadableReady(function () {
-                        var hydrateContext = _objectSpread(_objectSpread({}, context), {}, {
-                          _hydration: true
+                    streamSSRHydrate = function _streamSSRHydrate() {
+                      // callback: https://github.com/reactwg/react-18/discussions/5
+                      var SSRApp = function SSRApp() {
+                        return /*#__PURE__*/_jsx(WithCallback, {
+                          callback: callback,
+                          children: /*#__PURE__*/_jsx(App, {
+                            context: hydrateContext
+                          })
                         });
+                      };
 
-                        var callback = function callback() {
-                          // won't cause component re-render because context's reference identity doesn't change
-                          delete hydrateContext._hydration;
-                        }; // callback: https://github.com/reactwg/react-18/discussions/5
+                      SSRApp = hoistNonReactStatics(SSRApp, App);
+                      ModernHydrate( /*#__PURE__*/_jsx(SSRApp, {}));
+                    };
 
+                    stringSSRHydrate = function _stringSSRHydrate() {
+                      var _window, _window$_SSR_DATA;
 
-                        if (IS_REACT18) {
-                          var SSRApp = function SSRApp() {
-                            return /*#__PURE__*/_jsx(WithCallback, {
-                              callback: callback,
-                              children: /*#__PURE__*/_jsx(App, {
-                                context: hydrateContext
-                              })
-                            });
-                          };
+                      // if render level not exist, use client render
+                      var renderLevel = ((_window = window) === null || _window === void 0 ? void 0 : (_window$_SSR_DATA = _window._SSR_DATA) === null || _window$_SSR_DATA === void 0 ? void 0 : _window$_SSR_DATA.renderLevel) || RenderLevel.CLIENT_RENDER; // client render and server prefetch use same logic
 
-                          SSRApp = hoistNonReactStatics(SSRApp, App);
-                          ModernHydrate( /*#__PURE__*/_jsx(SSRApp, {}));
+                      if (renderLevel === RenderLevel.CLIENT_RENDER || renderLevel === RenderLevel.SERVER_PREFETCH) {
+                        ModernRender( /*#__PURE__*/_jsx(App, {
+                          context: context
+                        }));
+                      } else if (renderLevel === RenderLevel.SERVER_RENDER) {
+                        if (isReact18()) {
+                          loadableReady(function () {
+                            // callback: https://github.com/reactwg/react-18/discussions/5
+                            var SSRApp = function SSRApp() {
+                              return /*#__PURE__*/_jsx(WithCallback, {
+                                callback: callback,
+                                children: /*#__PURE__*/_jsx(App, {
+                                  context: hydrateContext
+                                })
+                              });
+                            };
+
+                            SSRApp = hoistNonReactStatics(SSRApp, App);
+                            ModernHydrate( /*#__PURE__*/_jsx(SSRApp, {}));
+                          });
                         } else {
-                          ModernHydrate( /*#__PURE__*/_jsx(App, {
-                            context: hydrateContext
-                          }), callback);
+                          loadableReady(function () {
+                            ModernHydrate( /*#__PURE__*/_jsx(App, {
+                              context: hydrateContext
+                            }), callback);
+                          });
                         }
-                      });
-                    } else {
-                      // unknown renderlevel or renderlevel is server prefetch.
-                      console.warn("unknow render level: ".concat(renderLevel, ", execute render()"));
-                      ModernRender( /*#__PURE__*/_jsx(App, {
-                        context: context
-                      }));
+                      } else {
+                        // unknown renderlevel or renderlevel is server prefetch.
+                        console.warn("unknow render level: ".concat(renderLevel, ", execute render()"));
+                        ModernRender( /*#__PURE__*/_jsx(App, {
+                          context: context
+                        }));
+                      }
+                    };
+
+                    App = _ref.App, context = _ref.context, ModernRender = _ref.ModernRender, ModernHydrate = _ref.ModernHydrate;
+                    hydrateContext = _objectSpread(_objectSpread({}, context), {}, {
+                      _hydration: true
+                    });
+
+                    callback = function callback() {
+                      // won't cause component re-render because context's reference identity doesn't change
+                      delete hydrateContext._hydration;
+                    }; // react streamSSR hydrate
+
+
+                    if (!(isReact18() && config.mode === 'stream')) {
+                      _context.next = 7;
+                      break;
                     }
 
-                  case 3:
+                    return _context.abrupt("return", streamSSRHydrate());
+
+                  case 7:
+                    return _context.abrupt("return", stringSSRHydrate());
+
+                  case 8:
                   case "end":
                     return _context.stop();
                 }

package/dist/js/treeshaking/ssr/index.node.js

@@ -2,9 +2,9 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { registerPrefetch } from "../core";
-import { render } from "./serverRender";
 import prefetch from "./prefetch";
 import { formatServer } from "./utils";
+import render from "./serverRender";
 var registeredApps = new WeakSet();
 export var ssr = function ssr() {
   var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
@@ -29,7 +29,11 @@ export var ssr = function ssr() {
                     }
 
                     _context2.next = 4;
-                    return render(context, config, App);
+                    return render({
+                      context: context,
+                      App: App,
+                      config: config
+                    });
 
                   case 4:
                     html = _context2.sent;

package/dist/js/treeshaking/ssr/serverRender/index.js

@@ -1,63 +1,49 @@
 import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import { run } from '@modern-js/utils/ssr';
-import { PreRender } from "../react/prerender";
-import SSREntry from "./entry";
-import { time } from "./measure";
-export var render = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(ctx, config, App) {
-    var ssrContext;
-    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+
+/* eslint-disable eslint-comments/disable-enable-pair */
+
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+/* eslint-disable @typescript-eslint/no-require-imports */
+import { isReact18 } from "../utils";
+export default function serverRender(_x) {
+  return _serverRender.apply(this, arguments);
+}
+
+function _serverRender() {
+  _serverRender = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(options) {
+    var pipe, html;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) {
-        switch (_context2.prev = _context2.next) {
+        switch (_context.prev = _context.next) {
           case 0:
-            ssrContext = ctx.ssrContext;
-            return _context2.abrupt("return", run(ssrContext.request.headers, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-              var entry, end, html, cost, cacheConfig;
-              return _regeneratorRuntime().wrap(function _callee$(_context) {
-                while (1) {
-                  switch (_context.prev = _context.next) {
-                    case 0:
-                      entry = new SSREntry({
-                        ctx: ssrContext,
-                        App: App,
-                        config: config
-                      });
-                      entry.metrics.emitCounter('app.visit.count', 1);
-                      end = time();
-                      _context.next = 5;
-                      return entry.renderToHtml(ctx);
-
-                    case 5:
-                      html = _context.sent;
-                      cost = end();
-                      entry.logger.info('App Render Total cost = %d ms', cost);
-                      entry.metrics.emitTimer('app.render.cost', cost);
-                      cacheConfig = PreRender.config();
-
-                      if (cacheConfig) {
-                        ctx.ssrContext.cacheConfig = cacheConfig;
-                      }
-
-                      return _context.abrupt("return", html);
-
-                    case 12:
-                    case "end":
-                      return _context.stop();
-                  }
-                }
-              }, _callee);
-            }))));
-
-          case 2:
+            if (!(isReact18() && options.config.mode === 'stream')) {
+              _context.next = 7;
+              break;
+            }
+
+            _context.next = 3;
+            return require("./renderToStream").render(options);
+
+          case 3:
+            pipe = _context.sent;
+            return _context.abrupt("return", pipe);
+
+          case 7:
+            _context.next = 9;
+            return require("./renderToString").render(options);
+
+          case 9:
+            html = _context.sent;
+            return _context.abrupt("return", html);
+
+          case 11:
           case "end":
-            return _context2.stop();
+            return _context.stop();
         }
       }
-    }, _callee2);
+    }, _callee);
   }));
-
-  return function render(_x, _x2, _x3) {
-    return _ref.apply(this, arguments);
-  };
-}();
+  return _serverRender.apply(this, arguments);
+}

package/dist/js/treeshaking/ssr/serverRender/renderToStream/buildTemplate.after.js

@@ -0,0 +1,33 @@
+import serialize from 'serialize-javascript';
+import { buildTemplate } from "./buildTemplate.share";
+export function buildShellAfterTemplate(afterAppTemplate, options) {
+  var callbacks = [injectSSRDataScript];
+  return buildTemplate(afterAppTemplate, callbacks);
+
+  function injectSSRDataScript(template) {
+    var ssrDataScript = buildSSRDataScript();
+    return template.replace('<!--<?- SSRDataScript ?>-->', ssrDataScript);
+
+    function buildSSRDataScript() {
+      var ssrContext = options.context.ssrContext;
+      var _ref = ssrContext,
+          request = _ref.request;
+      var SSRData = {
+        context: {
+          request: {
+            params: request.params,
+            query: request.query,
+            pathname: request.pathname,
+            host: request.host,
+            url: request.url,
+            headers: request.headers,
+            cookieMap: request.cookieMap
+          }
+        }
+      };
+      return "\n      <script>window._SSR_DATA = ".concat(serialize(SSRData, {
+        isJSON: true
+      }), "</script>\n      ");
+    }
+  }
+}

package/dist/js/treeshaking/ssr/serverRender/renderToStream/buildTemplate.share.js

@@ -0,0 +1,7 @@
+// share script
+export var HEAD_REG_EXP = /<head(.|\n)*>(.|\n)*<\/head>/;
+export function buildTemplate(template, callbacks) {
+  return callbacks.reduce(function (template, buildTemplateCb) {
+    return buildTemplateCb(template);
+  }, template);
+}

package/dist/js/treeshaking/ssr/serverRender/renderToStream/bulidTemplate.before.js

@@ -0,0 +1,29 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import ReactHelmet from 'react-helmet';
+import helmetReplace from "../helmet";
+import { HEAD_REG_EXP, buildTemplate } from "./buildTemplate.share"; // build head template
+
+function getHeadTemplate(beforeEntryTemplate) {
+  var callbacks = [function (headTemplate) {
+    var helmetData = ReactHelmet.renderStatic();
+    return helmetData ? helmetReplace(headTemplate, helmetData) : headTemplate;
+  }];
+
+  var _ref = beforeEntryTemplate.match(HEAD_REG_EXP) || [],
+      _ref2 = _slicedToArray(_ref, 1),
+      _ref2$ = _ref2[0],
+      headTemplate = _ref2$ === void 0 ? '' : _ref2$;
+
+  if (!headTemplate.length) {
+    return '';
+  }
+
+  return buildTemplate(headTemplate, callbacks); // @TODO: inject css chunks of lazy components
+  // @TODO: prefetch scripts of lazy component
+} // build script
+
+
+export function buildShellBeforeTemplate(beforeAppTemplate) {
+  var headTemplate = getHeadTemplate(beforeAppTemplate);
+  return beforeAppTemplate.replace(HEAD_REG_EXP, headTemplate);
+}

package/dist/js/treeshaking/ssr/serverRender/renderToStream/index.js

@@ -0,0 +1,120 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { createElement } from 'react';
+import { run } from '@modern-js/utils/ssr';
+import { PreRender } from "../../react/prerender";
+import { time } from "../utils";
+import { createTemplates } from "./template";
+import renderToPipe from "./renderToPipe";
+export var render = function render(_ref) {
+  var App = _ref.App,
+      context = _ref.context;
+  var ssrContext = context.ssrContext;
+
+  if (!ssrContext) {
+    throw new Error('The "ssrContext" must not be undefined, but received undefined');
+  }
+
+  return run(ssrContext.request.headers, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var end_all, rootElement, getTemplates, end, pipe;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            end_all = time();
+            rootElement = /*#__PURE__*/createElement(App, {
+              context: Object.assign(context || {}, {
+                ssr: true
+              })
+            });
+            getTemplates = createTemplates(context);
+            end = time();
+            pipe = renderToPipe(rootElement, getTemplates, {
+              onShellReady: function onShellReady() {
+                // set cacheConfig
+                var cacheConfig = PreRender.config();
+
+                if (cacheConfig) {
+                  context.ssrContext.cacheConfig = cacheConfig;
+                }
+              },
+              onAllReady: function onAllReady() {
+                // computed render html cost
+                var cost = end();
+                ssrContext.logger.debug('App Render To HTML cost = %d ms', cost);
+                ssrContext.metrics.emitTimer('app.render.html.cost', cost); // computed all ssr const
+
+                var cost_all = end_all();
+                ssrContext.logger.info('App Render Total cost = %d ms', cost_all);
+                ssrContext.metrics.emitTimer('app.render.cost', cost_all);
+              }
+            });
+            return _context.abrupt("return", pipe);
+
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }))); // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+  function prefetch(_x, _x2) {
+    return _prefetch.apply(this, arguments);
+  }
+
+  function _prefetch() {
+    _prefetch = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(App, context) {
+      var prefetch, ssrContext, prefetchData, end, prefetchCost;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              prefetch = App.prefetch;
+              ssrContext = context.ssrContext;
+              end = time();
+              _context2.prev = 3;
+
+              if (!prefetch) {
+                _context2.next = 10;
+                break;
+              }
+
+              _context2.next = 7;
+              return prefetch(context);
+
+            case 7:
+              _context2.t0 = _context2.sent;
+              _context2.next = 11;
+              break;
+
+            case 10:
+              _context2.t0 = null;
+
+            case 11:
+              prefetchData = _context2.t0;
+              prefetchCost = end();
+              ssrContext.logger.debug("App Prefetch cost = %d ms", prefetchCost);
+              ssrContext.metrics.emitTimer('app.prefetch.cost', prefetchCost);
+              _context2.next = 21;
+              break;
+
+            case 17:
+              _context2.prev = 17;
+              _context2.t1 = _context2["catch"](3);
+              ssrContext.logger.error('App Prefetch Render', _context2.t1);
+              ssrContext.metrics.emitCounter('app.prefetch.render.error', 1);
+
+            case 21:
+              return _context2.abrupt("return", prefetchData || {});
+
+            case 22:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, null, [[3, 17]]);
+    }));
+    return _prefetch.apply(this, arguments);
+  }
+};

package/dist/js/treeshaking/ssr/serverRender/renderToStream/loadable.js

@@ -0,0 +1,24 @@
+import { ChunkExtractor } from '@loadable/server';
+export function getLoadableChunks(_ref) {
+  var context = _ref.context,
+      jsx = _ref.jsx;
+  var _ref2 = context.ssrContext,
+      loadableStats = _ref2.loadableStats,
+      entryName = _ref2.entryName;
+
+  if (!loadableStats) {
+    return {
+      jsx: jsx
+    };
+  }
+
+  var extractor = new ChunkExtractor({
+    stats: loadableStats,
+    entrypoints: [entryName]
+  });
+  var collectedJsx = extractor.collectChunks(jsx);
+  return {
+    jsx: collectedJsx,
+    chunkExtractor: extractor
+  };
+}

package/dist/js/treeshaking/ssr/serverRender/renderToStream/renderToPipe.js

@@ -0,0 +1,57 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { Transform } from 'stream';
+import { renderToPipeableStream } from 'react-dom/server';
+
+function renderToPipe(rootElement, getTemplates, options) {
+  var isShellStream = true;
+
+  var forUserPipe = function forUserPipe(stream) {
+    return new Promise(function (resolve) {
+      var _renderToPipeableStre = renderToPipeableStream(rootElement, _objectSpread(_objectSpread({}, options), {}, {
+        onShellReady: function onShellReady() {
+          var _options$onShellReady;
+
+          options === null || options === void 0 ? void 0 : (_options$onShellReady = options.onShellReady) === null || _options$onShellReady === void 0 ? void 0 : _options$onShellReady.call(options);
+
+          var _getTemplates = getTemplates(),
+              shellAfter = _getTemplates.shellAfter,
+              shellBefore = _getTemplates.shellBefore;
+
+          var injectableTransform = new Transform({
+            transform: function transform(chunk, _encoding, callback) {
+              try {
+                if (isShellStream) {
+                  this.push(joinChunk(shellBefore, chunk, shellAfter));
+                  isShellStream = false;
+                } else {
+                  this.push(chunk);
+                }
+
+                callback();
+              } catch (e) {
+                if (e instanceof Error) {
+                  callback(e);
+                } else {
+                  callback(new Error('Received unkown error when streaming'));
+                }
+              }
+            }
+          });
+          resolve(pipe(injectableTransform).pipe(stream));
+        }
+      })),
+          pipe = _renderToPipeableStre.pipe;
+    });
+  };
+
+  return forUserPipe;
+
+  function joinChunk() {
+    var before = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    var chunk = arguments.length > 1 ? arguments[1] : undefined;
+    var after = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    return "".concat(before).concat(chunk.toString()).concat(after);
+  }
+}
+
+export default renderToPipe;

package/dist/js/treeshaking/ssr/serverRender/renderToStream/styledComponent.js

@@ -0,0 +1,10 @@
+import { ServerStyleSheet } from 'styled-components';
+export function getStyledComponentCss(_ref) {
+  var jsx = _ref.jsx;
+  var sheet = new ServerStyleSheet();
+  var collectedJsx = sheet.collectStyles(jsx);
+  return {
+    styleSheet: sheet,
+    jsx: collectedJsx
+  };
+}

package/dist/js/treeshaking/ssr/serverRender/renderToStream/template.js

@@ -0,0 +1,29 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { buildShellAfterTemplate } from "./buildTemplate.after";
+import { buildShellBeforeTemplate } from "./bulidTemplate.before";
+var HTML_SEPARATOR = '<!--<?- html ?>-->';
+export function createTemplates(context) {
+  var getTemplates = function getTemplates() {
+    var _ref = context.ssrContext,
+        template = _ref.template;
+
+    var _ref2 = template.split(HTML_SEPARATOR) || [],
+        _ref3 = _slicedToArray(_ref2, 2),
+        _ref3$ = _ref3[0],
+        beforeAppTemplate = _ref3$ === void 0 ? '' : _ref3$,
+        _ref3$2 = _ref3[1],
+        afterAppHtmlTemplate = _ref3$2 === void 0 ? '' : _ref3$2; // templates injected some variables
+
+
+    var builtBeforeTemplate = buildShellBeforeTemplate(beforeAppTemplate);
+    var builtAfterTemplate = buildShellAfterTemplate(afterAppHtmlTemplate, {
+      context: context
+    });
+    return {
+      shellBefore: builtBeforeTemplate,
+      shellAfter: builtAfterTemplate
+    };
+  };
+
+  return getTemplates;
+}

package/dist/js/treeshaking/ssr/serverRender/{entry.js → renderToString/entry.js}

@@ -8,13 +8,13 @@ import React from 'react';
 import ReactDomServer from 'react-dom/server';
 import serialize from 'serialize-javascript';
 import ReactHelmet from 'react-helmet';
+import helmetReplace from "../helmet";
+import { RenderLevel } from "../types";
+import { time } from "../utils";
 import { toFragments } from "./template";
-import { RenderLevel } from "./type";
-import helmetReplace from "./helmet";
 import { reduce } from "./reduce";
 import * as loadableRenderer from "./loadable";
 import * as styledComponentRenderer from "./styledComponent";
-import { time } from "./measure";
 
 var buildTemplateData = function buildTemplateData(context, data, renderLevel) {
   var request = context.request;

package/dist/js/treeshaking/ssr/serverRender/renderToString/index.js

@@ -0,0 +1,48 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { run } from '@modern-js/utils/ssr';
+import { PreRender } from "../../react/prerender";
+import { time } from "../utils";
+import SSREntry from "./entry";
+export var render = function render(_ref) {
+  var App = _ref.App,
+      context = _ref.context,
+      config = _ref.config;
+  var ssrContext = context.ssrContext;
+  return run(ssrContext.request.headers, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var entry, end, html, cost, cacheConfig;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            entry = new SSREntry({
+              ctx: ssrContext,
+              App: App,
+              config: config
+            });
+            entry.metrics.emitCounter('app.visit.count', 1);
+            end = time();
+            _context.next = 5;
+            return entry.renderToHtml(context);
+
+          case 5:
+            html = _context.sent;
+            cost = end();
+            entry.logger.info('App Render Total cost = %d ms', cost);
+            entry.metrics.emitTimer('app.render.cost', cost);
+            cacheConfig = PreRender.config();
+
+            if (cacheConfig) {
+              context.ssrContext.cacheConfig = cacheConfig;
+            }
+
+            return _context.abrupt("return", html);
+
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+};