@modern-js/runtime 2.14.0 → 2.15.1-alpha.0

package/dist/js/treeshaking/router/runtime/utils.js

@@ -0,0 +1,260 @@
+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;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+import { jsx } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { Route } from "react-router-dom";
+import { DefaultNotFound } from "./DefaultNotFound";
+var renderNestedRoute = function(nestedRoute, parent) {
+    var children = nestedRoute.children, index = nestedRoute.index, id = nestedRoute.id, component = nestedRoute.component, isRoot = nestedRoute.isRoot;
+    var Component = component;
+    var routeProps = {
+        caseSensitive: nestedRoute.caseSensitive,
+        path: nestedRoute.path,
+        id: nestedRoute.id,
+        loader: createLoader(nestedRoute),
+        action: nestedRoute.action,
+        hasErrorBoundary: nestedRoute.hasErrorBoundary,
+        shouldRevalidate: nestedRoute.shouldRevalidate,
+        handle: nestedRoute.handle,
+        index: nestedRoute.index,
+        element: nestedRoute.element,
+        errorElement: nestedRoute.errorElement
+    };
+    if (nestedRoute.error) {
+        var errorElement = /* @__PURE__ */ jsx(nestedRoute.error, {});
+        routeProps.errorElement = errorElement;
+    }
+    var element;
+    if (Component) {
+        if (parent === null || parent === void 0 ? void 0 : parent.loading) {
+            var Loading = parent.loading;
+            if (isLoadableComponent(Component)) {
+                element = /* @__PURE__ */ jsx(Component, {
+                    fallback: /* @__PURE__ */ jsx(Loading, {})
+                });
+            } else {
+                element = /* @__PURE__ */ jsx(Suspense, {
+                    fallback: /* @__PURE__ */ jsx(Loading, {}),
+                    children: /* @__PURE__ */ jsx(Component, {})
+                });
+            }
+        } else if (isLoadableComponent(Component) || isRoot) {
+            element = /* @__PURE__ */ jsx(Component, {});
+        } else {
+            element = /* @__PURE__ */ jsx(Suspense, {
+                fallback: null,
+                children: /* @__PURE__ */ jsx(Component, {})
+            });
+        }
+    } else {
+        nestedRoute.loading = parent === null || parent === void 0 ? void 0 : parent.loading;
+    }
+    if (element) {
+        routeProps.element = element;
+    }
+    var childElements = children === null || children === void 0 ? void 0 : children.map(function(childRoute) {
+        return renderNestedRoute(childRoute, nestedRoute);
+    });
+    var routeElement = index ? /* @__PURE__ */ jsx(Route, _objectSpreadProps(_objectSpread({}, routeProps), {
+        index: true
+    }), id) : /* @__PURE__ */ jsx(Route, _objectSpreadProps(_objectSpread({}, routeProps), {
+        index: false,
+        children: childElements
+    }), id);
+    return routeElement;
+};
+function getRouteComponents(routes, globalApp) {
+    var Layout = function(_param) {
+        var Component = _param.Component, props = _objectWithoutProperties(_param, [
+            "Component"
+        ]);
+        var GlobalLayout = globalApp;
+        if (!GlobalLayout) {
+            return /* @__PURE__ */ jsx(Component, _objectSpread({}, props));
+        }
+        return /* @__PURE__ */ jsx(GlobalLayout, _objectSpread({
+            Component: Component
+        }, props));
+    };
+    var routeElements = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = routes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var route = _step.value;
+            if (route.type === "nested") {
+                var routeElement = renderNestedRoute(route);
+                routeElements.push(routeElement);
+            } else {
+                var routeElement1 = /* @__PURE__ */ jsx(Route, {
+                    path: route.path,
+                    element: /* @__PURE__ */ jsx(Layout, {
+                        Component: route.component
+                    })
+                }, route.path);
+                routeElements.push(routeElement1);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    routeElements.push(/* @__PURE__ */ jsx(Route, {
+        path: "*",
+        element: /* @__PURE__ */ jsx(DefaultNotFound, {})
+    }, "*"));
+    return routeElements;
+}
+function renderRoutes(routesConfig) {
+    if (!routesConfig) {
+        return null;
+    }
+    var routes = routesConfig.routes, globalApp = routesConfig.globalApp;
+    if (!routes) {
+        return null;
+    }
+    var routeElements = getRouteComponents(routes, globalApp);
+    return routeElements;
+}
+function getLocation(serverContext) {
+    var ref;
+    var ref1 = (serverContext === null || serverContext === void 0 ? void 0 : serverContext.request) || {}, pathname = ref1.pathname, url = ref1.url;
+    var cleanUrl = (ref = url === null || url === void 0 ? void 0 : url.replace("http://", "")) === null || ref === void 0 ? void 0 : ref.replace("https://", "");
+    var index = (cleanUrl || "").indexOf(pathname);
+    if (index === -1) {
+        return pathname;
+    }
+    return cleanUrl.substring(index);
+}
+var urlJoin = function() {
+    for(var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++){
+        parts[_key] = arguments[_key];
+    }
+    var separator = "/";
+    var replace = new RegExp("".concat(separator, "{1,}"), "g");
+    return standardSlash(parts.join(separator).replace(replace, separator));
+};
+function standardSlash(str) {
+    var addr = str;
+    if (!addr || typeof addr !== "string") {
+        return addr;
+    }
+    if (addr.startsWith(".")) {
+        addr = addr.slice(1);
+    }
+    if (!addr.startsWith("/")) {
+        addr = "/".concat(addr);
+    }
+    if (addr.endsWith("/") && addr !== "/") {
+        addr = addr.slice(0, addr.length - 1);
+    }
+    return addr;
+}
+function createLoader(route) {
+    var loader = route.loader;
+    if (loader) {
+        return function(args) {
+            if (typeof route.lazyImport === "function") {
+                route.lazyImport();
+            }
+            return loader(args);
+        };
+    } else {
+        return function() {
+            if (typeof route.lazyImport === "function") {
+                route.lazyImport();
+            }
+            return null;
+        };
+    }
+}
+function isLoadableComponent(component) {
+    return component && component.displayName === "Loadable" && component.preload && typeof component.preload === "function";
+}
+export { getLocation, getRouteComponents, renderRoutes, standardSlash, urlJoin };

package/dist/js/treeshaking/router/runtime/withRouter.js

@@ -0,0 +1,67 @@
+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;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+import { jsx } from "react/jsx-runtime";
+import { useLocation, useNavigate, useParams } from "react-router-dom";
+var withRouter = function(Component) {
+    return function(props) {
+        var location = useLocation();
+        var params = useParams();
+        var navigate = useNavigate();
+        return /* @__PURE__ */ jsx(Component, _objectSpreadProps(_objectSpread({}, props), {
+            location: location,
+            params: params,
+            navigate: navigate
+        }));
+    };
+};
+export { withRouter };

package/dist/js/treeshaking/runtime-context.js

@@ -0,0 +1,4 @@
+import { createContext } from "react";
+var RuntimeReactContext = createContext({});
+var ServerRouterContext = createContext({});
+export { RuntimeReactContext, ServerRouterContext };

package/dist/js/treeshaking/ssr/cli/babel-plugin-ssr-loader-id.js

@@ -0,0 +1,122 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = function(cb, mod) {
+    return function __require() {
+        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
+            exports: {}
+        }).exports, mod), mod.exports;
+    };
+};
+import crypto from "crypto";
+import { Buffer as Buffer2 } from "buffer";
+import * as t from "@babel/types";
+import { get } from "@modern-js/utils/lodash";
+var require_babel_plugin_ssr_loader_id = __commonJS({
+    "src/ssr/cli/babel-plugin-ssr-loader-id.ts": function(exports, module) {
+        var getHash = function getHash(filepath) {
+            var cwd = process.cwd();
+            var point = filepath.indexOf(cwd);
+            var relativePath = filepath;
+            if (point !== -1) {
+                relativePath = filepath.substring(point + cwd.length);
+            }
+            var fileBuf = Buffer2.from(relativePath);
+            var fsHash = crypto.createHash("md5");
+            var md5 = fsHash.update(fileBuf).digest("hex");
+            return md5;
+        };
+        var getUseLoaderPath = function getUseLoaderPath(path, calleeName) {
+            var node = path.node;
+            if (!calleeName || node.callee.name !== calleeName) {
+                return false;
+            }
+            var arg1 = get(node, "arguments.0");
+            if (t.isFunction(arg1) || t.isFunctionExpression(arg1) || t.isArrowFunctionExpression(arg1) || t.isIdentifier(arg1) || t.isCallExpression(arg1) || t.isMemberExpression(arg1)) {
+                var loaderPath = path.get("arguments.0");
+                if (isDuplicateInnerLoader(loaderPath)) {
+                    return false;
+                } else {
+                    return loaderPath;
+                }
+            }
+            console.warn("useLoader 中 loaderId 生成失败，请检查 useLoader");
+            throw path.buildCodeFrameError("\n    please check the usage of ".concat(path.node.name, "\n  "));
+        };
+        var isDuplicateInnerLoader = function isDuplicateInnerLoader(path) {
+            var node = path.node;
+            if (t.isFunctionExpression(node.callee)) {
+                if (t.isBlockStatement(node.callee.body)) {
+                    if (get(node.callee.body, "body.0.declarations.0.id.name") === "innerLoader" && get(node.callee.body, "body.2.argument.name") === "innerLoader") {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        var getSelfRunLoaderExpression = function getSelfRunLoaderExpression(loaderExpression, id) {
+            return t.callExpression(t.functionExpression(null, [], t.blockStatement([
+                t.variableDeclaration("var", [
+                    t.variableDeclarator(t.identifier("innerLoader"), loaderExpression)
+                ]),
+                t.expressionStatement(t.assignmentExpression("=", t.memberExpression(t.identifier("innerLoader"), t.identifier("id")), t.stringLiteral(id))),
+                t.returnStatement(t.identifier("innerLoader"))
+            ])), []);
+        };
+        var RUNTIME_PACKAGE_NAMES = [
+            "@modern-js/runtime"
+        ];
+        var FUNCTION_USE_LOADER_NAME = "useLoader";
+        module.exports = function() {
+            var genId = function genId() {
+                return "".concat(hash, "_").concat(index++);
+            };
+            var useLoader = null;
+            var hash = "";
+            var index = 0;
+            return {
+                name: "babel-plugin-ssr-loader-id",
+                pre: function pre() {
+                    index = 0;
+                    useLoader = null;
+                    hash = "";
+                },
+                visitor: {
+                    ImportDeclaration: function ImportDeclaration(path, state) {
+                        if (useLoader) {
+                            return false;
+                        }
+                        if (!RUNTIME_PACKAGE_NAMES.includes(get(path, "node.source.value"))) {
+                            return false;
+                        }
+                        hash = getHash(state.file.opts.filename);
+                        get(path, "node.specifiers", []).forEach(function(param) {
+                            var imported = param.imported, local = param.local;
+                            if (!imported) {
+                                throw path.buildCodeFrameError("please `import { useLoader } from ".concat(RUNTIME_PACKAGE_NAMES[0], "`"));
+                            }
+                            if (!useLoader && imported.name === FUNCTION_USE_LOADER_NAME) {
+                                useLoader = local.name;
+                            }
+                        });
+                        return false;
+                    },
+                    CallExpression: function CallExpression(path) {
+                        var loaderPath = getUseLoaderPath(path, useLoader);
+                        if (loaderPath) {
+                            if (!Array.isArray(loaderPath)) {
+                                loaderPath = [
+                                    loaderPath
+                                ];
+                            }
+                            loaderPath.forEach(function(p) {
+                                p.replaceWith(getSelfRunLoaderExpression(p.node, genId()));
+                            });
+                            return false;
+                        }
+                        return false;
+                    }
+                }
+            };
+        };
+    }
+});
+export default require_babel_plugin_ssr_loader_id();

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

@@ -0,0 +1,217 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+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;
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _toArray(arr) {
+    return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import path from "path";
+import { getEntryOptions, SERVER_RENDER_FUNCTION_NAME, LOADABLE_STATS_FILE, isUseSSRBundle, createRuntimeExportsUtils, isSingleEntry } from "@modern-js/utils";
+var PLUGIN_IDENTIFIER = "ssr";
+var hasStringSSREntry = function(userConfig) {
+    var isStreaming = function(ssr) {
+        return ssr && typeof ssr === "object" && ssr.mode === "stream";
+    };
+    var server = userConfig.server;
+    if ((server === null || server === void 0 ? void 0 : server.ssr) && !isStreaming(server.ssr)) {
+        return true;
+    }
+    if ((server === null || server === void 0 ? void 0 : server.ssrByEntries) && typeof server.ssrByEntries === "object") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = Object.keys(server.ssrByEntries)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var name = _step.value;
+                if (!isStreaming(server.ssrByEntries[name])) {
+                    return true;
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return false;
+};
+var cli_default = function() {
+    return {
+        name: "@modern-js/plugin-ssr",
+        required: [
+            "@modern-js/runtime"
+        ],
+        setup: function(api) {
+            var ssrConfigMap = /* @__PURE__ */ new Map();
+            var pluginsExportsUtils;
+            return {
+                config: function config() {
+                    var appContext = api.useAppContext();
+                    pluginsExportsUtils = createRuntimeExportsUtils(appContext.internalDirectory, "plugins");
+                    return {
+                        source: {
+                            alias: {
+                                "@modern-js/runtime/plugins": pluginsExportsUtils.getPath()
+                            }
+                        },
+                        tools: {
+                            webpackChain: function(chain, param) {
+                                var name = param.name, isServer = param.isServer, CHAIN_ID = param.CHAIN_ID;
+                                var userConfig = api.useResolvedConfigContext();
+                                if (isUseSSRBundle(userConfig) && name !== "server" && hasStringSSREntry(userConfig)) {
+                                    var LoadableWebpackPlugin = require("@loadable/webpack-plugin");
+                                    chain.plugin(CHAIN_ID.PLUGIN.LOADABLE).use(LoadableWebpackPlugin, [
+                                        {
+                                            filename: LOADABLE_STATS_FILE
+                                        }
+                                    ]);
+                                }
+                                var modernVars = _defineProperty({}, "process.env.MODERN_TARGET", JSON.stringify(isServer ? "node" : "browser"));
+                                chain.plugin(CHAIN_ID.PLUGIN.DEFINE).tap(function(args) {
+                                    var _args = _toArray(args), vars = _args[0], rest = _args.slice(1);
+                                    return [
+                                        _objectSpread({}, vars, modernVars)
+                                    ].concat(_toConsumableArray(rest));
+                                });
+                            },
+                            babel: function(config) {
+                                config.plugins.push(path.join(__dirname, "./babel-plugin-ssr-loader-id"));
+                                var userConfig = api.useResolvedConfigContext();
+                                if (isUseSSRBundle(userConfig) && hasStringSSREntry(userConfig)) {
+                                    config.plugins.push(require.resolve("@loadable/babel-plugin"));
+                                }
+                            }
+                        }
+                    };
+                },
+                modifyEntryImports: function modifyEntryImports(param) {
+                    var entrypoint = param.entrypoint, imports = param.imports;
+                    var entryName = entrypoint.entryName, fileSystemRoutes = entrypoint.fileSystemRoutes;
+                    var userConfig = api.useResolvedConfigContext();
+                    var ref = api.useAppContext(), packageName = ref.packageName, entrypoints = ref.entrypoints;
+                    pluginsExportsUtils.addExport("export { default as ssr } from '@modern-js/runtime/ssr'");
+                    var ssrConfig = getEntryOptions(entryName, userConfig.server.ssr, userConfig.server.ssrByEntries, packageName);
+                    if (typeof ssrConfig === "object" && ssrConfig.mode === "stream") {
+                        var ref1;
+                        var runtimeConfig = getEntryOptions(entryName, userConfig.runtime, userConfig.runtimeByEntries, packageName);
+                        if ((runtimeConfig === null || runtimeConfig === void 0 ? void 0 : (ref1 = runtimeConfig.router) === null || ref1 === void 0 ? void 0 : ref1.mode) === "react-router-5") {
+                            throw new Error("router v5 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.");
+                        }
+                    }
+                    var ssgConfig = userConfig.output.ssg;
+                    var 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);
+                    if (ssrConfig || useSSG) {
+                        imports.push({
+                            value: "@modern-js/runtime/plugins",
+                            specifiers: [
+                                {
+                                    imported: PLUGIN_IDENTIFIER
+                                }
+                            ]
+                        });
+                    }
+                    return {
+                        entrypoint: entrypoint,
+                        imports: imports
+                    };
+                },
+                modifyEntryRuntimePlugins: function modifyEntryRuntimePlugins(param) {
+                    var entrypoint = param.entrypoint, plugins = param.plugins;
+                    if (ssrConfigMap.get(entrypoint.entryName)) {
+                        plugins.push({
+                            name: PLUGIN_IDENTIFIER,
+                            options: JSON.stringify(ssrConfigMap.get(entrypoint.entryName))
+                        });
+                    }
+                    return {
+                        entrypoint: entrypoint,
+                        plugins: plugins
+                    };
+                },
+                modifyEntryExport: function modifyEntryExport(param) {
+                    var entrypoint = param.entrypoint, exportStatement = param.exportStatement;
+                    if (ssrConfigMap.get(entrypoint.entryName)) {
+                        return {
+                            entrypoint: entrypoint,
+                            exportStatement: [
+                                "export function ".concat(SERVER_RENDER_FUNCTION_NAME, "(context) {\n              return bootstrap(AppWrapper, context)\n            }"),
+                                exportStatement
+                            ].join("\n")
+                        };
+                    }
+                    return {
+                        entrypoint: entrypoint,
+                        exportStatement: exportStatement
+                    };
+                }
+            };
+        }
+    };
+};
+export { cli_default as default };