@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).
+
+## Credist
+
+Thanks to:
+
+- [@loadable/webpack-plugin](https://github.com/gregberge/loadable-components) to create a webpack plugin prepare for loadable usage in ssr.

package/dist/cjs/cache/index.js

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_modules__ = {
+    "@modern-js/runtime-utils/cache" (module) {
+        module.exports = require("@modern-js/runtime-utils/cache");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _modern_js_runtime_utils_cache__rspack_import_0 = __webpack_require__("@modern-js/runtime-utils/cache");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _modern_js_runtime_utils_cache__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_modern_js_runtime_utils_cache__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/alias.js

@@ -0,0 +1,68 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    builderPluginAlias: ()=>builderPluginAlias
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const builderPluginAlias = ({ entrypoints, internalDirectory, metaName })=>({
+        name: 'runtime:alias',
+        setup (api) {
+            api.modifyRsbuildConfig((userConfig, { mergeRsbuildConfig })=>{
+                const entrypointsAlias = {};
+                const mainEntrypointsAlias = {};
+                entrypoints.forEach((entrypoint)=>{
+                    entrypointsAlias[`@${metaName}/runtime/registry/${entrypoint.entryName}$`] = external_path_default().join(internalDirectory, entrypoint.entryName, external_constants_js_namespaceObject.ENTRY_POINT_REGISTER_FILE_NAME);
+                    if (entrypoint.isMainEntry) mainEntrypointsAlias[`@${metaName}/runtime/registry`] = external_path_default().join(internalDirectory, entrypoint.entryName, external_constants_js_namespaceObject.ENTRY_POINT_REGISTER_FILE_NAME);
+                });
+                return mergeRsbuildConfig(userConfig, {
+                    resolve: {
+                        alias: {
+                            ...entrypointsAlias,
+                            ...mainEntrypointsAlias
+                        }
+                    }
+                });
+            });
+        }
+    });
+exports.builderPluginAlias = __webpack_exports__.builderPluginAlias;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builderPluginAlias"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/code.js

@@ -0,0 +1,193 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    generateCode: ()=>generateCode
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const mode_js_namespaceObject = require("./ssr/mode.js");
+const external_template_js_namespaceObject = require("./template.js");
+const external_template_server_js_namespaceObject = require("./template.server.js");
+const normalizePreEntry = (preEntry)=>{
+    if (!preEntry) return [];
+    if (Array.isArray(preEntry)) return preEntry.filter((v)=>'string' == typeof v && v.length > 0);
+    if ('string' == typeof preEntry) return preEntry ? [
+        preEntry
+    ] : [];
+    return [];
+};
+const resolvePreEntryImportPath = ({ preEntry, appDirectory, srcDirectory, internalSrcAlias })=>{
+    const absPath = external_path_default().isAbsolute(preEntry) ? preEntry : external_path_default().resolve(appDirectory, preEntry);
+    if (absPath.startsWith(srcDirectory)) return (0, utils_namespaceObject.formatImportPath)(absPath.replace(srcDirectory, internalSrcAlias));
+    return (0, utils_namespaceObject.formatImportPath)(absPath);
+};
+const generateCode = async (entrypoints, appContext, config, hooks)=>{
+    const { mountId } = config.html;
+    const { enableAsyncEntry, enableAsyncPreEntry, preEntry } = config.source;
+    const shouldInjectAsyncPreEntry = !!enableAsyncEntry && !!enableAsyncPreEntry;
+    const { appDirectory, runtimeConfigFile, internalDirectory, internalSrcAlias, metaName, srcDirectory, serverRoutes } = appContext;
+    await Promise.all(entrypoints.map(async (entrypoint)=>{
+        const { entryName, isAutoMount, entry, customEntry, customServerEntry, nestedRoutesEntry } = entrypoint;
+        const { plugins: runtimePlugins } = await hooks._internalRuntimePlugins.call({
+            entrypoint,
+            plugins: []
+        });
+        if (isAutoMount) {
+            const ssrMode = (0, mode_js_namespaceObject.resolveSSRMode)({
+                entry: entryName,
+                config,
+                nestedRoutesEntry
+            });
+            let indexCode = '';
+            indexCode = ssrMode || !config.server.rsc || customEntry ? external_template_js_namespaceObject.index({
+                srcDirectory,
+                internalSrcAlias,
+                metaName,
+                entry,
+                entryName,
+                customEntry,
+                mountId,
+                enableRsc: config.server.rsc,
+                isNestedRouter: !!entrypoint.nestedRoutesEntry
+            }) : external_template_js_namespaceObject.entryForCSRWithRSC({
+                metaName,
+                entryName,
+                mountId,
+                urlPath: serverRoutes.find((route)=>route.entryName === entryName)?.urlPath,
+                isNestedRouter: entrypoint.nestedRoutesEntry
+            });
+            if (shouldInjectAsyncPreEntry) {
+                const preEntries = normalizePreEntry(preEntry);
+                if (preEntries.length > 0) {
+                    const injected = preEntries.map((item)=>{
+                        const importPath = resolvePreEntryImportPath({
+                            preEntry: item,
+                            appDirectory,
+                            srcDirectory,
+                            internalSrcAlias
+                        });
+                        return `import '${importPath}';`;
+                    }).join('\n');
+                    indexCode = `${injected}\n${indexCode}`;
+                }
+            }
+            const indexFile = external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.ENTRY_POINT_FILE_NAME}`);
+            await utils_namespaceObject.fs.outputFile(indexFile, indexCode, 'utf8');
+            if (enableAsyncEntry) {
+                const bootstrapFile = external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.ENTRY_BOOTSTRAP_FILE_NAME}`);
+                await utils_namespaceObject.fs.outputFile(bootstrapFile, `import(/* webpackChunkName: "async-${entryName}" */ './${external_constants_js_namespaceObject.INDEX_FILE_NAME}');`, 'utf8');
+                const bootstrapServerFile = external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.ENTRY_SERVER_BOOTSTRAP_FILE_NAME}`);
+                if (ssrMode) await utils_namespaceObject.fs.outputFile(bootstrapServerFile, `export const requestHandler = import('./${external_constants_js_namespaceObject.SERVER_ENTRY_POINT_FILE_NAME}').then((m) => m.requestHandler)`, 'utf8');
+            }
+            if (ssrMode) {
+                const indexServerCode = external_template_server_js_namespaceObject.serverIndex({
+                    entry,
+                    entryName,
+                    internalSrcAlias,
+                    metaName,
+                    mode: ssrMode,
+                    customServerEntry,
+                    srcDirectory,
+                    enableRsc: config.server.rsc
+                });
+                const indexServerFile = external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.SERVER_ENTRY_POINT_FILE_NAME}`);
+                await utils_namespaceObject.fs.outputFile(indexServerFile, indexServerCode, 'utf8');
+            } else if (config.server.rsc) {
+                const indexServerFile = external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.SERVER_ENTRY_POINT_FILE_NAME}`);
+                const indexServerCode = external_template_server_js_namespaceObject.entryForCSRWithRSC({
+                    entryName,
+                    metaName
+                });
+                await utils_namespaceObject.fs.outputFile(indexServerFile, indexServerCode, 'utf8');
+            }
+            const registerCode = external_template_js_namespaceObject.register();
+            const registerFile = external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.ENTRY_POINT_REGISTER_FILE_NAME}`);
+            await utils_namespaceObject.fs.outputFile(registerFile, registerCode, 'utf8');
+            const registerRuntimeCode = external_template_js_namespaceObject.runtimeRegister({
+                entryName,
+                srcDirectory,
+                internalSrcAlias,
+                metaName,
+                runtimeConfigFile,
+                runtimePlugins
+            });
+            const registerRuntimeFile = external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME}`);
+            await utils_namespaceObject.fs.outputFile(registerRuntimeFile, registerRuntimeCode, 'utf8');
+            let contextCode = '';
+            if (!config.server.rsc || entrypoint.nestedRoutesEntry) {
+                const route = serverRoutes.find((r)=>r.entryName === entryName);
+                const basename = route?.urlPath || '/';
+                contextCode = external_template_js_namespaceObject.runtimeGlobalContext({
+                    entryName,
+                    srcDirectory,
+                    internalSrcAlias,
+                    metaName,
+                    entry,
+                    customEntry,
+                    basename
+                });
+            } else {
+                const AppProxyPath = external_path_default().join(internalDirectory, entryName, './AppProxy.jsx');
+                const appProxyCode = external_template_js_namespaceObject.AppProxyForRSC({
+                    srcDirectory,
+                    internalSrcAlias,
+                    entry,
+                    customEntry
+                });
+                await utils_namespaceObject.fs.outputFile(AppProxyPath, appProxyCode);
+                contextCode = external_template_js_namespaceObject.runtimeGlobalContextForRSCClient({
+                    metaName,
+                    customEntry
+                });
+                const contextServerCode = external_template_js_namespaceObject.runtimeGlobalContextForRSCServer({
+                    metaName
+                });
+                const contextFile = external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.server.js`);
+                await utils_namespaceObject.fs.outputFile(contextFile, contextServerCode, 'utf8');
+            }
+            const contextFile = external_path_default().resolve(internalDirectory, `./${entryName}/${external_constants_js_namespaceObject.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.js`);
+            await utils_namespaceObject.fs.outputFile(contextFile, contextCode, 'utf8');
+        }
+    }));
+};
+exports.generateCode = __webpack_exports__.generateCode;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateCode"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/constants.js

@@ -0,0 +1,68 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    APP_FILE_NAME: ()=>APP_FILE_NAME,
+    ENTRY_BOOTSTRAP_FILE_NAME: ()=>ENTRY_BOOTSTRAP_FILE_NAME,
+    ENTRY_POINT_FILE_NAME: ()=>ENTRY_POINT_FILE_NAME,
+    ENTRY_POINT_REGISTER_FILE_NAME: ()=>ENTRY_POINT_REGISTER_FILE_NAME,
+    ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME: ()=>ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME,
+    ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME: ()=>ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME,
+    ENTRY_SERVER_BOOTSTRAP_FILE_NAME: ()=>ENTRY_SERVER_BOOTSTRAP_FILE_NAME,
+    INDEX_FILE_NAME: ()=>INDEX_FILE_NAME,
+    SERVER_ENTRY_POINT_FILE_NAME: ()=>SERVER_ENTRY_POINT_FILE_NAME
+});
+const APP_FILE_NAME = 'App';
+const ENTRY_POINT_FILE_NAME = 'index.jsx';
+const SERVER_ENTRY_POINT_FILE_NAME = 'index.server.jsx';
+const INDEX_FILE_NAME = 'index';
+const ENTRY_BOOTSTRAP_FILE_NAME = 'bootstrap.jsx';
+const ENTRY_SERVER_BOOTSTRAP_FILE_NAME = 'bootstrap.server.jsx';
+const ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME = 'runtime-register.js';
+const ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME = 'runtime-global-context';
+const ENTRY_POINT_REGISTER_FILE_NAME = 'register.js';
+exports.APP_FILE_NAME = __webpack_exports__.APP_FILE_NAME;
+exports.ENTRY_BOOTSTRAP_FILE_NAME = __webpack_exports__.ENTRY_BOOTSTRAP_FILE_NAME;
+exports.ENTRY_POINT_FILE_NAME = __webpack_exports__.ENTRY_POINT_FILE_NAME;
+exports.ENTRY_POINT_REGISTER_FILE_NAME = __webpack_exports__.ENTRY_POINT_REGISTER_FILE_NAME;
+exports.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME = __webpack_exports__.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME;
+exports.ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME = __webpack_exports__.ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME;
+exports.ENTRY_SERVER_BOOTSTRAP_FILE_NAME = __webpack_exports__.ENTRY_SERVER_BOOTSTRAP_FILE_NAME;
+exports.INDEX_FILE_NAME = __webpack_exports__.INDEX_FILE_NAME;
+exports.SERVER_ENTRY_POINT_FILE_NAME = __webpack_exports__.SERVER_ENTRY_POINT_FILE_NAME;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "APP_FILE_NAME",
+    "ENTRY_BOOTSTRAP_FILE_NAME",
+    "ENTRY_POINT_FILE_NAME",
+    "ENTRY_POINT_REGISTER_FILE_NAME",
+    "ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME",
+    "ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME",
+    "ENTRY_SERVER_BOOTSTRAP_FILE_NAME",
+    "INDEX_FILE_NAME",
+    "SERVER_ENTRY_POINT_FILE_NAME"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/entry.js

@@ -0,0 +1,53 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    hasApp: ()=>hasApp,
+    isRuntimeEntry: ()=>isRuntimeEntry
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const hasApp = (dir)=>(0, utils_namespaceObject.findExists)(utils_namespaceObject.JS_EXTENSIONS.map((ext)=>external_path_default().resolve(dir, `${external_constants_js_namespaceObject.APP_FILE_NAME}${ext}`)));
+const isRuntimeEntry = (dir)=>hasApp(dir);
+exports.hasApp = __webpack_exports__.hasApp;
+exports.isRuntimeEntry = __webpack_exports__.isRuntimeEntry;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "hasApp",
+    "isRuntimeEntry"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/index.js

@@ -0,0 +1,166 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>cli,
+    documentPlugin: ()=>index_js_namespaceObject.documentPlugin,
+    getEntrypointRoutesDir: ()=>external_router_cli_index_js_namespaceObject.getEntrypointRoutesDir,
+    handleFileChange: ()=>external_router_cli_index_js_namespaceObject.handleFileChange,
+    handleGeneratorEntryCode: ()=>external_router_cli_index_js_namespaceObject.handleGeneratorEntryCode,
+    handleModifyEntrypoints: ()=>external_router_cli_index_js_namespaceObject.handleModifyEntrypoints,
+    isRouteEntry: ()=>external_router_cli_index_js_namespaceObject.isRouteEntry,
+    isRuntimeEntry: ()=>external_entry_js_namespaceObject.isRuntimeEntry,
+    routerPlugin: ()=>external_router_cli_index_js_namespaceObject.routerPlugin,
+    runtimePlugin: ()=>runtimePlugin,
+    ssrPlugin: ()=>external_ssr_index_js_namespaceObject.ssrPlugin
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const index_js_namespaceObject = require("../document/cli/index.js");
+const external_router_cli_index_js_namespaceObject = require("../router/cli/index.js");
+const external_alias_js_namespaceObject = require("./alias.js");
+const external_code_js_namespaceObject = require("./code.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_entry_js_namespaceObject = require("./entry.js");
+const external_ssr_index_js_namespaceObject = require("./ssr/index.js");
+const runtimePlugin = (params)=>({
+        name: '@modern-js/runtime',
+        post: [
+            '@modern-js/plugin-ssr',
+            '@modern-js/plugin-router',
+            '@modern-js/plugin-document',
+            '@modern-js/plugin-design-token'
+        ],
+        usePlugins: params?.plugins || [
+            (0, external_ssr_index_js_namespaceObject.ssrPlugin)(),
+            (0, external_router_cli_index_js_namespaceObject.routerPlugin)(),
+            (0, index_js_namespaceObject.documentPlugin)()
+        ],
+        setup: (api)=>{
+            api.checkEntryPoint(({ path, entry })=>({
+                    path,
+                    entry: entry || (0, external_entry_js_namespaceObject.isRuntimeEntry)(path)
+                }));
+            api.modifyEntrypoints(({ entrypoints })=>{
+                const { internalDirectory } = api.getAppContext();
+                const { source: { enableAsyncEntry } } = api.getNormalizedConfig();
+                const newEntryPoints = entrypoints.map((entrypoint)=>{
+                    if (entrypoint.isAutoMount) entrypoint.internalEntry = external_path_default().resolve(internalDirectory, `./${entrypoint.entryName}/${enableAsyncEntry ? external_constants_js_namespaceObject.ENTRY_BOOTSTRAP_FILE_NAME : external_constants_js_namespaceObject.ENTRY_POINT_FILE_NAME}`);
+                    return entrypoint;
+                });
+                return {
+                    entrypoints: newEntryPoints
+                };
+            });
+            api.generateEntryCode(async ({ entrypoints })=>{
+                const appContext = api.getAppContext();
+                const resolvedConfig = api.getNormalizedConfig();
+                const hooks = api.getHooks();
+                await (0, external_code_js_namespaceObject.generateCode)(entrypoints, appContext, resolvedConfig, hooks);
+            });
+            api.onPrepare(()=>{
+                const { builder, entrypoints, internalDirectory, metaName } = api.getAppContext();
+                builder?.addPlugins([
+                    (0, external_alias_js_namespaceObject.builderPluginAlias)({
+                        entrypoints,
+                        internalDirectory,
+                        metaName
+                    })
+                ]);
+            });
+            api.config(()=>{
+                const { appDirectory, metaName } = api.getAppContext();
+                const isReact18 = (0, utils_namespaceObject.isReact18)(appDirectory);
+                process.env.IS_REACT18 = isReact18.toString();
+                return {
+                    source: {
+                        globalVars: {
+                            'process.env.IS_REACT18': process.env.IS_REACT18
+                        },
+                        include: [
+                            new RegExp(`[\\\\/]node_modules[\\\\/]@${metaName}[\\\\/]runtime[\\\\/].*[\\\\/]head\\.`)
+                        ]
+                    },
+                    tools: {
+                        bundlerChain: (chain)=>{
+                            chain.module.rule('modern-entry').test(/\.jsx?$/).include.add(external_path_default().resolve(appDirectory, 'node_modules', `.${metaName}`)).end().sideEffects(true);
+                        },
+                        rspack: (_config, { appendPlugins, rspack })=>{
+                            if (!isReact18) appendPlugins([
+                                new rspack.IgnorePlugin({
+                                    resourceRegExp: /^react-dom\/client$/,
+                                    contextRegExp: /@modern-js\/runtime/
+                                })
+                            ]);
+                        }
+                    }
+                };
+            });
+            api.onBeforeRestart(()=>{
+                (0, utils_namespaceObject.cleanRequireCache)([
+                    require.resolve('../router/cli'),
+                    require.resolve('./ssr')
+                ]);
+            });
+        }
+    });
+const cli = runtimePlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.documentPlugin = __webpack_exports__.documentPlugin;
+exports.getEntrypointRoutesDir = __webpack_exports__.getEntrypointRoutesDir;
+exports.handleFileChange = __webpack_exports__.handleFileChange;
+exports.handleGeneratorEntryCode = __webpack_exports__.handleGeneratorEntryCode;
+exports.handleModifyEntrypoints = __webpack_exports__.handleModifyEntrypoints;
+exports.isRouteEntry = __webpack_exports__.isRouteEntry;
+exports.isRuntimeEntry = __webpack_exports__.isRuntimeEntry;
+exports.routerPlugin = __webpack_exports__.routerPlugin;
+exports.runtimePlugin = __webpack_exports__.runtimePlugin;
+exports.ssrPlugin = __webpack_exports__.ssrPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "documentPlugin",
+    "getEntrypointRoutesDir",
+    "handleFileChange",
+    "handleGeneratorEntryCode",
+    "handleModifyEntrypoints",
+    "isRouteEntry",
+    "isRuntimeEntry",
+    "routerPlugin",
+    "runtimePlugin",
+    "ssrPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});