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

package/dist/js/modern/ssr/cli/index.js

@@ -1,5 +1,28 @@
 import { getEntryOptions, SERVER_RENDER_FUNCTION_NAME, LOADABLE_STATS_FILE, isUseSSRBundle, createRuntimeExportsUtils, isSingleEntry } from '@modern-js/utils';
 const PLUGIN_IDENTIFIER = 'ssr';
+
+const hasStringSSREntry = userConfig => {
+  const isStreaming = ssr => ssr && typeof ssr === 'object' && ssr.mode === 'stream';
+
+  const {
+    server
+  } = userConfig;
+
+  if (server !== null && server !== void 0 && server.ssr && !isStreaming(server.ssr)) {
+    return true;
+  }
+
+  if (server !== null && server !== void 0 && server.ssrByEntries && typeof server.ssrByEntries === 'object') {
+    for (const name of Object.keys(server.ssrByEntries)) {
+      if (!isStreaming(server.ssrByEntries[name])) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
 export default (() => ({
   name: '@modern-js/plugin-ssr',
   required: ['@modern-js/runtime'],
@@ -23,9 +46,9 @@ export default (() => ({
             }) => {
               const userConfig = api.useResolvedConfigContext();
 
-              if (isUseSSRBundle(userConfig) && name !== 'server') {
+              if (isUseSSRBundle(userConfig) && name !== 'server' && hasStringSSREntry(userConfig)) {
                 // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
-                const LoadableWebpackPlugin = require('@modern-js/webpack/@loadable/webpack-plugin');
+                const LoadableWebpackPlugin = require('@loadable/webpack-plugin');
 
                 chain.plugin(CHAIN_ID.PLUGIN.LOADABLE).use(LoadableWebpackPlugin, [{
                   filename: LOADABLE_STATS_FILE
@@ -35,7 +58,7 @@ export default (() => ({
             babel: config => {
               const userConfig = api.useResolvedConfigContext();
 
-              if (isUseSSRBundle(userConfig)) {
+              if (isUseSSRBundle(userConfig) && hasStringSSREntry(userConfig)) {
                 config.plugins.push(require.resolve('@loadable/babel-plugin'));
               }
             }
@@ -48,7 +71,8 @@ export default (() => ({
         imports
       }) {
         const {
-          entryName
+          entryName,
+          fileSystemRoutes
         } = entrypoint;
         const userConfig = api.useResolvedConfigContext();
         const {
@@ -58,6 +82,21 @@ export default (() => ({
         pluginsExportsUtils.addExport(`export { default as ssr } from '@modern-js/runtime/ssr'`); // if use ssg then set ssr config to true
 
         const ssrConfig = getEntryOptions(entryName, userConfig.server.ssr, userConfig.server.ssrByEntries, packageName);
+
+        if (typeof ssrConfig === 'object' && ssrConfig.mode === 'stream') {
+          var _runtimeConfig$router;
+
+          const runtimeConfig = getEntryOptions(entryName, userConfig.runtime, userConfig.runtimeByEntries, packageName);
+
+          if (runtimeConfig !== null && runtimeConfig !== void 0 && (_runtimeConfig$router = runtimeConfig.router) !== null && _runtimeConfig$router !== void 0 && _runtimeConfig$router.legacy) {
+            throw new Error(`Legacy router plugin doesn't support streaming SSR, check your config 'runtime.router'`);
+          }
+
+          if (fileSystemRoutes && !entrypoint.nestedRoutesEntry) {
+            throw new Error(`You should switch to file-system based router to support streaming SSR.`);
+          }
+        }
+
         const ssgConfig = userConfig.output.ssg;
         const useSSG = isSingleEntry(entrypoints) ? Boolean(ssgConfig) : ssgConfig === true || typeof (ssgConfig === null || ssgConfig === void 0 ? void 0 : ssgConfig[0]) === 'function' || Boolean(ssgConfig === null || ssgConfig === void 0 ? void 0 : ssgConfig[entryName]);
         ssrConfigMap.set(entryName, ssrConfig || useSSG);
@@ -84,7 +123,7 @@ export default (() => ({
         if (ssrConfigMap.get(entrypoint.entryName)) {
           plugins.push({
             name: PLUGIN_IDENTIFIER,
-            options: ssrConfigMap.get(entrypoint.entryName)
+            options: JSON.stringify(ssrConfigMap.get(entrypoint.entryName))
           });
         }
 

package/dist/js/modern/ssr/index.js

@@ -6,12 +6,11 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 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";
-const IS_REACT18 = process.env.IS_REACT18 === 'true';
-export const ssr = _ => ({
+export const ssr = config => ({
   name: '@modern-js/plugin-ssr',
   setup: () => {
     const mockResp = mockResponse();
@@ -22,49 +21,74 @@ export const ssr = _ => ({
         ModernRender,
         ModernHydrate
       }) => {
-        var _window, _window$_SSR_DATA;
-
-        // if render level not exist, use client render
-        const 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(() => {
-            const hydrateContext = _objectSpread(_objectSpread({}, context), {}, {
-              _hydration: true
-            });
-
-            const 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
-
-
-            if (IS_REACT18) {
-              let SSRApp = () => /*#__PURE__*/_jsx(WithCallback, {
-                callback: callback,
-                children: /*#__PURE__*/_jsx(App, {
-                  context: hydrateContext
-                })
-              });
+        const hydrateContext = _objectSpread(_objectSpread({}, context), {}, {
+          _hydration: true
+        });
+
+        const 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') {
+          return streamSSRHydrate();
+        } // react stringSSR hydrate
+
+
+        return stringSSRHydrate();
+
+        function stringSSRHydrate() {
+          var _window, _window$_SSR_DATA;
 
-              SSRApp = hoistNonReactStatics(SSRApp, App);
-              ModernHydrate( /*#__PURE__*/_jsx(SSRApp, {}));
+          // if render level not exist, use client render
+          const 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) {
+            if (isReact18()) {
+              loadableReady(() => {
+                // callback: https://github.com/reactwg/react-18/discussions/5
+                let SSRApp = () => /*#__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(() => {
+                ModernHydrate( /*#__PURE__*/_jsx(App, {
+                  context: hydrateContext
+                }), callback);
+              });
             }
+          } else {
+            // unknown renderlevel or renderlevel is server prefetch.
+            console.warn(`unknow render level: ${renderLevel}, execute render()`);
+            ModernRender( /*#__PURE__*/_jsx(App, {
+              context: context
+            }));
+          }
+        }
+
+        function streamSSRHydrate() {
+          // callback: https://github.com/reactwg/react-18/discussions/5
+          let SSRApp = () => /*#__PURE__*/_jsx(WithCallback, {
+            callback: callback,
+            children: /*#__PURE__*/_jsx(App, {
+              context: hydrateContext
+            })
           });
-        } else {
-          // unknown renderlevel or renderlevel is server prefetch.
-          console.warn(`unknow render level: ${renderLevel}, execute render()`);
-          ModernRender( /*#__PURE__*/_jsx(App, {
-            context: context
-          }));
+
+          SSRApp = hoistNonReactStatics(SSRApp, App);
+          ModernHydrate( /*#__PURE__*/_jsx(SSRApp, {}));
         }
       },
 

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

@@ -5,9 +5,9 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 import { registerPrefetch } from "../core";
-import { render } from "./serverRender";
 import prefetch from "./prefetch";
 import { formatServer } from "./utils";
+import render from "./serverRender";
 const registeredApps = new WeakSet();
 export const ssr = (config = {}) => ({
   name: '@modern-js/plugin-ssr',
@@ -22,7 +22,11 @@ export const ssr = (config = {}) => ({
           registeredApps.add(App);
         }
 
-        const html = await render(context, config, App);
+        const html = await render({
+          context: context,
+          App: App,
+          config
+        });
         return html;
       },
 

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

@@ -1,29 +1,15 @@
-import { run } from '@modern-js/utils/ssr';
-import { PreRender } from "../react/prerender";
-import SSREntry from "./entry";
-import { time } from "./measure";
-export const render = async (ctx, config, App) => {
-  const {
-    ssrContext
-  } = ctx;
-  return run(ssrContext.request.headers, async () => {
-    const entry = new SSREntry({
-      ctx: ssrContext,
-      App,
-      config
-    });
-    entry.metrics.emitCounter('app.visit.count', 1);
-    const end = time();
-    const html = await entry.renderToHtml(ctx);
-    const cost = end();
-    entry.logger.info('App Render Total cost = %d ms', cost);
-    entry.metrics.emitTimer('app.render.cost', cost);
-    const cacheConfig = PreRender.config();
+/* eslint-disable eslint-comments/disable-enable-pair */
 
-    if (cacheConfig) {
-      ctx.ssrContext.cacheConfig = cacheConfig;
-    }
+/* eslint-disable @typescript-eslint/no-var-requires */
 
+/* eslint-disable @typescript-eslint/no-require-imports */
+import { isReact18 } from "../utils";
+export default async function serverRender(options) {
+  if (isReact18() && options.config.mode === 'stream') {
+    const pipe = await require("./renderToStream").render(options);
+    return pipe;
+  } else {
+    const html = await require("./renderToString").render(options);
     return html;
-  });
-};
+  }
+}

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

@@ -0,0 +1,38 @@
+import serialize from 'serialize-javascript';
+import { buildTemplate } from "./buildTemplate.share";
+export 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 {
+        ssrContext
+      } = options.context;
+      const {
+        request
+      } = ssrContext;
+      const 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 `
+      <script>window._SSR_DATA = ${serialize(SSRData, {
+        isJSON: true
+      })}</script>
+      `;
+    }
+  }
+}

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

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

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

@@ -0,0 +1,24 @@
+import ReactHelmet from 'react-helmet';
+import helmetReplace from "../helmet";
+import { HEAD_REG_EXP, buildTemplate } from "./buildTemplate.share"; // build head template
+
+function getHeadTemplate(beforeEntryTemplate) {
+  const callbacks = [headTemplate => {
+    const helmetData = ReactHelmet.renderStatic();
+    return helmetData ? helmetReplace(headTemplate, helmetData) : headTemplate;
+  }];
+  const [headTemplate = ''] = beforeEntryTemplate.match(HEAD_REG_EXP) || [];
+
+  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) {
+  const headTemplate = getHeadTemplate(beforeAppTemplate);
+  return beforeAppTemplate.replace(HEAD_REG_EXP, headTemplate);
+}

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

@@ -0,0 +1,73 @@
+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 const render = ({
+  App,
+  context
+}) => {
+  const {
+    ssrContext
+  } = context;
+
+  if (!ssrContext) {
+    throw new Error('The "ssrContext" must not be undefined, but received undefined');
+  }
+
+  return run(ssrContext.request.headers, async () => {
+    const end_all = time();
+    const rootElement = /*#__PURE__*/createElement(App, {
+      context: Object.assign(context || {}, {
+        ssr: true
+      })
+    });
+    const getTemplates = createTemplates(context);
+    const end = time();
+    const pipe = renderToPipe(rootElement, getTemplates, {
+      onShellReady() {
+        // set cacheConfig
+        const cacheConfig = PreRender.config();
+
+        if (cacheConfig) {
+          context.ssrContext.cacheConfig = cacheConfig;
+        }
+      },
+
+      onAllReady() {
+        // computed render html cost
+        const 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
+
+        const cost_all = end_all();
+        ssrContext.logger.info('App Render Total cost = %d ms', cost_all);
+        ssrContext.metrics.emitTimer('app.render.cost', cost_all);
+      }
+
+    });
+    return pipe;
+  }); // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+  async function prefetch(App, context) {
+    const {
+      prefetch
+    } = App;
+    const ssrContext = context.ssrContext;
+    let prefetchData;
+    const end = time();
+
+    try {
+      prefetchData = prefetch ? await prefetch(context) : null;
+      const prefetchCost = end();
+      ssrContext.logger.debug(`App Prefetch cost = %d ms`, prefetchCost);
+      ssrContext.metrics.emitTimer('app.prefetch.cost', prefetchCost);
+    } catch (e) {
+      ssrContext.logger.error('App Prefetch Render', e);
+      ssrContext.metrics.emitCounter('app.prefetch.render.error', 1);
+    }
+
+    return prefetchData || {};
+  }
+};

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

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

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

@@ -0,0 +1,61 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { Transform } from 'stream';
+import { renderToPipeableStream } from 'react-dom/server';
+
+function renderToPipe(rootElement, getTemplates, options) {
+  let isShellStream = true;
+
+  const forUserPipe = stream => {
+    return new Promise(resolve => {
+      const {
+        pipe
+      } = renderToPipeableStream(rootElement, _objectSpread(_objectSpread({}, options), {}, {
+        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);
+          const {
+            shellAfter,
+            shellBefore
+          } = getTemplates();
+          const injectableTransform = new Transform({
+            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));
+        }
+
+      }));
+    });
+  };
+
+  return forUserPipe;
+
+  function joinChunk(before = '', chunk, after = '') {
+    return `${before}${chunk.toString()}${after}`;
+  }
+}
+
+export default renderToPipe;

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

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

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

@@ -0,0 +1,22 @@
+import { buildShellAfterTemplate } from "./buildTemplate.after";
+import { buildShellBeforeTemplate } from "./bulidTemplate.before";
+const HTML_SEPARATOR = '<!--<?- html ?>-->';
+export function createTemplates(context) {
+  const getTemplates = () => {
+    const {
+      template
+    } = context.ssrContext;
+    const [beforeAppTemplate = '', afterAppHtmlTemplate = ''] = template.split(HTML_SEPARATOR) || []; // templates injected some variables
+
+    const builtBeforeTemplate = buildShellBeforeTemplate(beforeAppTemplate);
+    const builtAfterTemplate = buildShellAfterTemplate(afterAppHtmlTemplate, {
+      context
+    });
+    return {
+      shellBefore: builtBeforeTemplate,
+      shellAfter: builtAfterTemplate
+    };
+  };
+
+  return getTemplates;
+}

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

@@ -4,13 +4,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";
 
 const buildTemplateData = (context, data, renderLevel) => {
   const {
@@ -80,9 +80,7 @@ export default class Entry {
   }
 
   async renderToHtml(context) {
-    const {
-      ssrContext
-    } = context;
+    const ssrContext = context.ssrContext;
 
     if (ssrContext.redirection.url) {
       return '';

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

@@ -0,0 +1,31 @@
+import { run } from '@modern-js/utils/ssr';
+import { PreRender } from "../../react/prerender";
+import { time } from "../utils";
+import SSREntry from "./entry";
+export const render = ({
+  App,
+  context,
+  config
+}) => {
+  const ssrContext = context.ssrContext;
+  return run(ssrContext.request.headers, async () => {
+    const entry = new SSREntry({
+      ctx: ssrContext,
+      App,
+      config
+    });
+    entry.metrics.emitCounter('app.visit.count', 1);
+    const end = time();
+    const html = await entry.renderToHtml(context);
+    const cost = end();
+    entry.logger.info('App Render Total cost = %d ms', cost);
+    entry.metrics.emitTimer('app.render.cost', cost);
+    const cacheConfig = PreRender.config();
+
+    if (cacheConfig) {
+      context.ssrContext.cacheConfig = cacheConfig;
+    }
+
+    return html;
+  });
+};

package/dist/js/modern/ssr/serverRender/{loadable.js → renderToString/loadable.js}

@@ -1,22 +1,14 @@
 import { ChunkExtractor } from '@loadable/server';
-import { isCrossOrigin } from "../utils";
+import { isCrossOrigin } from "../../utils";
+import { getLoadableScripts } from "../utils";
 
 const extname = uri => {
-  return uri.match(/\.[^.]+$/) || '';
-};
-
-function getLoadableScripts(extractor) {
-  const check = scripts => (scripts || '').includes('__LOADABLE_REQUIRED_CHUNKS___ext');
-
-  const scripts = extractor.getScriptTags();
-
-  if (!check(scripts)) {
+  if (typeof uri !== 'string' || !uri.includes('.')) {
     return '';
   }
 
-  return scripts.split('</script>') // 前两个 script为 loadable 必须的 script
-  .slice(0, 2).map(i => `${i}</script>`).join('');
-}
+  return `.${uri === null || uri === void 0 ? void 0 : uri.split('.').pop()}` || '';
+};
 
 export const toHtml = (jsx, renderer, next) => {
   const {

package/dist/js/modern/ssr/serverRender/{type.js → renderToString/type.js}

@@ -1,4 +1,3 @@
-// import { IncomingHttpHeaders } from 'http';
 export let RenderLevel;
 
 (function (RenderLevel) {

package/dist/js/modern/ssr/serverRender/types.js

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