@module-federation/rsbuild-plugin 0.24.1 → 2.0.1

package/dist/cli/index.mjs

@@ -0,0 +1,360 @@
+import { parseOptions } from "@module-federation/enhanced";
+import { ModuleFederationPlugin, PLUGIN_NAME, TreeShakingSharedPlugin } from "@module-federation/enhanced/rspack";
+import { createModuleFederationConfig, getManifestFileName, isRequiredVersion } from "@module-federation/sdk";
+import package_0 from "../../package.json";
+import logger from "../logger.mjs";
+import { SSR_DIR, SSR_ENV_NAME, addDataFetchExposes, autoDeleteSplitChunkCacheGroups, createSSRMFConfig, createSSRREnvConfig, isRegExp, patchSSRRspackConfig, setSSREnv, updateStatsAndManifest } from "../utils.mjs";
+import { CALL_NAME_MAP, RSPRESS_BUNDLER_CONFIG_NAME, RSPRESS_SSG_MD_ENV_NAME, RSPRESS_SSR_DIR } from "../constant.mjs";
+import { ENV_NAME, patchNodeConfig, patchNodeMFConfig, patchToolsTspack } from "../utils/ssr.mjs";
+
+;// CONCATENATED MODULE: external "@module-federation/enhanced"
+
+;// CONCATENATED MODULE: external "@module-federation/enhanced/rspack"
+
+;// CONCATENATED MODULE: external "@module-federation/sdk"
+
+;// CONCATENATED MODULE: external "../../package.json"
+
+;// CONCATENATED MODULE: external "../logger.mjs"
+
+;// CONCATENATED MODULE: external "../utils.mjs"
+
+;// CONCATENATED MODULE: external "../constant.mjs"
+
+;// CONCATENATED MODULE: external "../utils/ssr.mjs"
+
+;// CONCATENATED MODULE: ./src/cli/index.ts
+
+
+
+
+
+
+
+
+const RSBUILD_PLUGIN_MODULE_FEDERATION_NAME = 'rsbuild:module-federation-enhanced';
+const RSBUILD_PLUGIN_NAME = '@module-federation/rsbuild-plugin';
+
+const LIB_FORMAT = [
+    'umd',
+    'modern-module'
+];
+const DEFAULT_MF_ENVIRONMENT_NAME = 'mf';
+function isStoryBook(rsbuildConfig) {
+    var _rsbuildConfig_plugins;
+    if ((_rsbuildConfig_plugins = rsbuildConfig.plugins) === null || _rsbuildConfig_plugins === void 0 ? void 0 : _rsbuildConfig_plugins.find((p)=>p && 'name' in p && p.name === 'module-federation-storybook-plugin')) {
+        return true;
+    }
+    return false;
+}
+function isMFFormat(bundlerConfig) {
+    var _bundlerConfig_output;
+    const library = (_bundlerConfig_output = bundlerConfig.output) === null || _bundlerConfig_output === void 0 ? void 0 : _bundlerConfig_output.library;
+    if (bundlerConfig.name === SSR_ENV_NAME) {
+        return true;
+    }
+    return !(typeof library === 'object' && !Array.isArray(library) && 'type' in library && //  if the type is umd/modern-module or commonjs*, means this is a normal library , not mf
+    (LIB_FORMAT.includes(library.type) || /commonjs/.test(library.type)));
+}
+const isSSRConfig = (bundlerConfigName)=>Boolean(bundlerConfigName === SSR_ENV_NAME);
+const isRspressSSGConfig = (bundlerConfigName)=>{
+    return [
+        RSPRESS_BUNDLER_CONFIG_NAME,
+        RSPRESS_SSG_MD_ENV_NAME
+    ].includes(bundlerConfigName || '');
+};
+const pluginModuleFederation = (moduleFederationOptions, rsbuildOptions)=>({
+        name: RSBUILD_PLUGIN_MODULE_FEDERATION_NAME,
+        setup: (api)=>{
+            const { target = 'web', ssr = undefined, ssrDir = SSR_DIR, environment = DEFAULT_MF_ENVIRONMENT_NAME } = rsbuildOptions || {};
+            if (ssr) {
+                throw new Error("The `ssr` option is deprecated. If you want to enable SSR, please use `target: 'dual'` instead.");
+            }
+            const { callerName } = api.context;
+            const originalRsbuildConfig = api.getRsbuildConfig();
+            if (!callerName) {
+                throw new Error('`callerName` is undefined. Please ensure the @rsbuild/core version is higher than 1.3.21 .');
+            }
+            const isRslib = callerName === CALL_NAME_MAP.RSLIB;
+            const isRspress = callerName === CALL_NAME_MAP.RSPRESS;
+            const isSSR = target === 'dual';
+            if (isSSR && !isStoryBook(originalRsbuildConfig)) {
+                var _rsbuildConfig_environments;
+                if (!isRslib && !isRspress) {
+                    throw new Error(`'target' option is only supported in Rslib.`);
+                }
+                const rsbuildConfig = api.getRsbuildConfig();
+                if (!isRspress && (!((_rsbuildConfig_environments = rsbuildConfig.environments) === null || _rsbuildConfig_environments === void 0 ? void 0 : _rsbuildConfig_environments[environment]) || Object.keys(rsbuildConfig.environments).some((key)=>key.startsWith(environment) && key !== environment))) {
+                    throw new Error(`Please set ${RSBUILD_PLUGIN_NAME} as global plugin in rslib.config.ts if you set 'target: "dual"'.`);
+                }
+                setSSREnv();
+            }
+            const sharedOptions = parseOptions(moduleFederationOptions.shared || [], (item, key)=>{
+                if (typeof item !== 'string') throw new Error('Unexpected array in shared');
+                const config = item === key || !isRequiredVersion(item) ? {
+                    import: item
+                } : {
+                    import: key,
+                    requiredVersion: item
+                };
+                return config;
+            }, (item)=>item);
+            // shared[0] is the shared name
+            const shared = sharedOptions.map((shared)=>shared[0].endsWith('/') ? shared[0].slice(0, -1) : shared[0]);
+            api.modifyRsbuildConfig((config)=>{
+                // skip storybook
+                if (isStoryBook(config)) {
+                    return;
+                }
+                // Change some default configs for remote modules
+                if (moduleFederationOptions.exposes) {
+                    var _userConfig_server, _config_server, _config_dev_client, _originalConfig_dev, _config_server1;
+                    config.dev ||= {};
+                    config.server ||= {};
+                    const userConfig = api.getRsbuildConfig('original');
+                    // Allow remote modules to be loaded by setting CORS headers
+                    // This is required for MF to work properly across different origins
+                    config.server.headers ||= {};
+                    if (!config.server.headers['Access-Control-Allow-Origin'] && !(typeof ((_userConfig_server = userConfig.server) === null || _userConfig_server === void 0 ? void 0 : _userConfig_server.cors) === 'object' && userConfig.server.cors.origin)) {
+                        const corsWarnMsgs = [
+                            'Detect that CORS options are not set, mf Rsbuild plugin will add default cors header: server.headers["Access-Control-Allow-Headers"] = "*". It is recommended to specify an allowlist of trusted origins in "server.cors" instead.',
+                            'View https://module-federation.io/guide/troubleshooting/other.html#cors-warn for more details.'
+                        ];
+                        !isRslib && !isRspress && logger.warn(corsWarnMsgs.join('\n'));
+                        config.server.headers['Access-Control-Allow-Origin'] = '*';
+                    }
+                    // For remote modules, Rsbuild should send the ws request to the provider's dev server.
+                    // This allows the provider to do HMR when the provider module is loaded in the consumer's page.
+                    if (((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.port) && !((_config_dev_client = config.dev.client) === null || _config_dev_client === void 0 ? void 0 : _config_dev_client.port)) {
+                        config.dev.client ||= {};
+                        config.dev.client.port = config.server.port;
+                    }
+                    // Change the default assetPrefix to `true` for remote modules.
+                    // This ensures that the remote module's assets can be requested by consumer apps with the correct URL.
+                    const originalConfig = api.getRsbuildConfig('original');
+                    if (((_originalConfig_dev = originalConfig.dev) === null || _originalConfig_dev === void 0 ? void 0 : _originalConfig_dev.assetPrefix) === undefined && config.dev.assetPrefix === ((_config_server1 = config.server) === null || _config_server1 === void 0 ? void 0 : _config_server1.base)) {
+                        config.dev.assetPrefix = true;
+                    }
+                }
+                if (isSSR) {
+                    var _config_environments, _config_environments1;
+                    if ((_config_environments = config.environments) === null || _config_environments === void 0 ? void 0 : _config_environments[SSR_ENV_NAME]) {
+                        throw new Error(`'${SSR_ENV_NAME}' environment is already defined.Please use another name.`);
+                    }
+                    config.environments[SSR_ENV_NAME] = createSSRREnvConfig((_config_environments1 = config.environments) === null || _config_environments1 === void 0 ? void 0 : _config_environments1[environment], moduleFederationOptions, ssrDir, config, callerName);
+                    const ssgMDEnv = config.environments[RSPRESS_SSG_MD_ENV_NAME];
+                    if (isRspress && ssgMDEnv) {
+                        patchToolsTspack(ssgMDEnv, (config, { environment })=>{
+                            config.target = 'async-node';
+                        });
+                    }
+                } else if (target === 'node') {
+                    const mfEnv = config.environments[ENV_NAME];
+                    patchToolsTspack(mfEnv, (config, { environment })=>{
+                        config.target = 'async-node';
+                    });
+                }
+            });
+            api.modifyEnvironmentConfig((config)=>{
+                // Module Federation runtime uses ES6+ syntax,
+                // adding to include and let SWC transform it
+                config.source.include = [
+                    ...config.source.include || [],
+                    /@module-federation[\\/]/
+                ];
+                return config;
+            });
+            const generateMergedStatsAndManifestOptions = {
+                options: {
+                    nodePlugin: undefined,
+                    browserPlugin: undefined,
+                    rspressSSGPlugin: undefined,
+                    distOutputDir: undefined,
+                    browserEnvironmentName: undefined,
+                    nodeEnvironmentName: undefined
+                },
+                assetResources: {},
+                isSSRConfig,
+                isRspressSSGConfig
+            };
+            api.expose(RSBUILD_PLUGIN_MODULE_FEDERATION_NAME, generateMergedStatsAndManifestOptions);
+            const defaultBrowserEnvironmentName = environment;
+            const assetFileNames = getManifestFileName(moduleFederationOptions.manifest);
+            if (moduleFederationOptions.manifest !== false) {
+                api.processAssets({
+                    stage: 'report'
+                }, ({ assets, environment: envContext })=>{
+                    const expectedBrowserEnv = generateMergedStatsAndManifestOptions.options.browserEnvironmentName ?? defaultBrowserEnvironmentName;
+                    const expectedNodeEnv = generateMergedStatsAndManifestOptions.options.nodeEnvironmentName ?? SSR_ENV_NAME;
+                    const envName = envContext.name;
+                    if (envName !== expectedBrowserEnv && envName !== expectedNodeEnv) {
+                        return;
+                    }
+                    const assetResources = generateMergedStatsAndManifestOptions.assetResources;
+                    const targetResources = assetResources[envName] || (assetResources[envName] = {});
+                    const statsAsset = assets[assetFileNames.statsFileName];
+                    if (statsAsset) {
+                        try {
+                            const raw = statsAsset.source();
+                            const content = typeof raw === 'string' ? raw : raw.toString();
+                            targetResources.stats = {
+                                data: JSON.parse(content),
+                                filename: assetFileNames.statsFileName
+                            };
+                        } catch (err) {
+                            const message = err instanceof Error ? err.message : String(err);
+                            logger.error(`Failed to parse stats asset "${assetFileNames.statsFileName}" for environment "${envName}": ${message} `);
+                        }
+                    }
+                    const manifestAsset = assets[assetFileNames.manifestFileName];
+                    if (manifestAsset) {
+                        try {
+                            const raw = manifestAsset.source();
+                            const content = typeof raw === 'string' ? raw : raw.toString();
+                            targetResources.manifest = {
+                                data: JSON.parse(content),
+                                filename: assetFileNames.manifestFileName
+                            };
+                        } catch (err) {
+                            const message = err instanceof Error ? err.message : String(err);
+                            logger.error(`Failed to parse manifest asset "${assetFileNames.manifestFileName}" for environment "${envName}": ${message} `);
+                        }
+                    }
+                });
+            }
+            api.onBeforeCreateCompiler(({ bundlerConfigs })=>{
+                if (!bundlerConfigs) {
+                    throw new Error('Can not get bundlerConfigs!');
+                }
+                bundlerConfigs.forEach((bundlerConfig)=>{
+                    if (!isMFFormat(bundlerConfig) && !isRspress) {
+                        return;
+                    } else if (isStoryBook(originalRsbuildConfig)) {
+                        bundlerConfig.output.uniqueName = `${moduleFederationOptions.name} -storybook - host`;
+                    } else {
+                        var _bundlerConfig_optimization, _bundlerConfig_optimization1, _bundlerConfig_output, _bundlerConfig_output1, _bundlerConfig_output2;
+                        // mf
+                        autoDeleteSplitChunkCacheGroups(moduleFederationOptions, bundlerConfig === null || bundlerConfig === void 0 ? void 0 : (_bundlerConfig_optimization = bundlerConfig.optimization) === null || _bundlerConfig_optimization === void 0 ? void 0 : _bundlerConfig_optimization.splitChunks);
+                        addDataFetchExposes(moduleFederationOptions.exposes, isSSRConfig(bundlerConfig.name));
+                        (_bundlerConfig_optimization1 = bundlerConfig.optimization) === null || _bundlerConfig_optimization1 === void 0 ? true : delete _bundlerConfig_optimization1.runtimeChunk;
+                        const externals = bundlerConfig.externals;
+                        if (Array.isArray(externals)) {
+                            const sharedModules = new Set();
+                            bundlerConfig.externals = externals.filter((ext)=>{
+                                let sharedModule;
+                                if (isRegExp(ext)) {
+                                    const match = shared.some((dep)=>{
+                                        if (ext.test(dep) || ext.test(package_0.name)) {
+                                            sharedModule = dep;
+                                            return true;
+                                        }
+                                        return false;
+                                    });
+                                    match && sharedModule && sharedModules.add(sharedModule);
+                                    return !match;
+                                }
+                                if (typeof ext === 'string') {
+                                    if (ext === package_0.name) {
+                                        return false;
+                                    }
+                                    const match = shared.some((dep)=>{
+                                        if (dep === ext) {
+                                            sharedModule = dep;
+                                        }
+                                        return dep === ext;
+                                    });
+                                    if (match) {
+                                        sharedModule && sharedModules.add(sharedModule);
+                                        return false;
+                                    }
+                                    return true;
+                                }
+                                return true;
+                            });
+                            if (sharedModules.size > 0) {
+                                for (const sharedModule of sharedModules){
+                                    logger.log(`${sharedModule} is removed from externals because it is a shared module.`);
+                                }
+                            }
+                        }
+                        if (!((_bundlerConfig_output = bundlerConfig.output) === null || _bundlerConfig_output === void 0 ? void 0 : _bundlerConfig_output.chunkLoadingGlobal) && !isSSRConfig(bundlerConfig.name) && !isRspressSSGConfig(bundlerConfig.name) && target !== 'node') {
+                            bundlerConfig.output.chunkLoading = 'jsonp';
+                            bundlerConfig.output.chunkLoadingGlobal = `chunk_${moduleFederationOptions.name} `;
+                        }
+                        if (target === 'node' && isMFFormat(bundlerConfig)) {
+                            patchNodeConfig(bundlerConfig, moduleFederationOptions);
+                            patchNodeMFConfig(moduleFederationOptions);
+                        }
+                        // `uniqueName` is required for react refresh to work
+                        if (!((_bundlerConfig_output1 = bundlerConfig.output) === null || _bundlerConfig_output1 === void 0 ? void 0 : _bundlerConfig_output1.uniqueName)) {
+                            bundlerConfig.output.uniqueName = moduleFederationOptions.name;
+                        }
+                        // Set default publicPath to 'auto' if not explicitly configured
+                        // This allows remote chunks to load from the same origin as the remote application's manifest
+                        if (((_bundlerConfig_output2 = bundlerConfig.output) === null || _bundlerConfig_output2 === void 0 ? void 0 : _bundlerConfig_output2.publicPath) === undefined && !isSSRConfig(bundlerConfig.name) && !isRspressSSGConfig(bundlerConfig.name)) {
+                            bundlerConfig.output.publicPath = 'auto';
+                        }
+                        if (!bundlerConfig.plugins.find((p)=>p && p.name === PLUGIN_NAME)) {
+                            var _bundlerConfig_output3;
+                            if (isSSRConfig(bundlerConfig.name)) {
+                                generateMergedStatsAndManifestOptions.options.nodePlugin = new ModuleFederationPlugin(createSSRMFConfig(moduleFederationOptions));
+                                generateMergedStatsAndManifestOptions.options.nodeEnvironmentName = bundlerConfig.name || SSR_ENV_NAME;
+                                bundlerConfig.plugins.push(generateMergedStatsAndManifestOptions.options.nodePlugin);
+                                return;
+                            } else if (isRspressSSGConfig(bundlerConfig.name)) {
+                                const mfConfig = {
+                                    ...createSSRMFConfig(moduleFederationOptions),
+                                    // expose in mf-ssg env
+                                    exposes: {},
+                                    manifest: false,
+                                    library: undefined
+                                };
+                                patchSSRRspackConfig(bundlerConfig, mfConfig, RSPRESS_SSR_DIR, callerName, false, false);
+                                bundlerConfig.output ||= {};
+                                bundlerConfig.output.publicPath = '/';
+                                // MF depend on asyncChunks
+                                bundlerConfig.output.asyncChunks = undefined;
+                                const p = new ModuleFederationPlugin(mfConfig);
+                                if (bundlerConfig.name === RSPRESS_BUNDLER_CONFIG_NAME) {
+                                    generateMergedStatsAndManifestOptions.options.rspressSSGPlugin = p;
+                                }
+                                bundlerConfig.plugins.push(p);
+                                return;
+                            }
+                            generateMergedStatsAndManifestOptions.options.browserPlugin = new ModuleFederationPlugin(moduleFederationOptions);
+                            generateMergedStatsAndManifestOptions.options.distOutputDir = ((_bundlerConfig_output3 = bundlerConfig.output) === null || _bundlerConfig_output3 === void 0 ? void 0 : _bundlerConfig_output3.path) || '';
+                            generateMergedStatsAndManifestOptions.options.browserEnvironmentName = bundlerConfig.name || defaultBrowserEnvironmentName;
+                            bundlerConfig.plugins.push(generateMergedStatsAndManifestOptions.options.browserPlugin);
+                        }
+                    }
+                });
+            });
+            const generateMergedStatsAndManifest = ()=>{
+                const { distOutputDir, browserEnvironmentName, nodeEnvironmentName } = generateMergedStatsAndManifestOptions.options;
+                if (!distOutputDir || !browserEnvironmentName || !nodeEnvironmentName) {
+                    return;
+                }
+                const assetResources = generateMergedStatsAndManifestOptions.assetResources;
+                const browserAssets = assetResources[browserEnvironmentName];
+                const nodeAssets = assetResources[nodeEnvironmentName];
+                if (!browserAssets || !nodeAssets) {
+                    return;
+                }
+                try {
+                    updateStatsAndManifest(nodeAssets, browserAssets, distOutputDir);
+                } catch (err) {
+                    logger.error(err);
+                }
+            };
+            api.onDevCompileDone(()=>{
+                generateMergedStatsAndManifest();
+            });
+            api.onAfterBuild(()=>{
+                generateMergedStatsAndManifest();
+            });
+        }
+    });
+
+
+
+export { PLUGIN_NAME, RSBUILD_PLUGIN_MODULE_FEDERATION_NAME, SSR_DIR, TreeShakingSharedPlugin, createModuleFederationConfig, isMFFormat, pluginModuleFederation };

package/dist/constant.d.ts

@@ -6,4 +6,5 @@ export declare const CALL_NAME_MAP: {
     RSLIB: string;
 };
 export declare const RSPRESS_BUNDLER_CONFIG_NAME = "node";
+export declare const RSPRESS_SSG_MD_ENV_NAME = "node_md";
 export declare const RSPRESS_SSR_DIR = "ssr";

package/dist/constant.js

@@ -1,35 +1,50 @@
 "use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
 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/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
 })();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
 })();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
 })();
+/************************************************************************/
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    CALL_NAME_MAP: ()=>CALL_NAME_MAP,
-    DATA_FETCH_CLIENT_SUFFIX: ()=>DATA_FETCH_CLIENT_SUFFIX,
-    DATA_FETCH_IDENTIFIER: ()=>DATA_FETCH_IDENTIFIER,
-    DEFAULT_ASSET_PREFIX: ()=>DEFAULT_ASSET_PREFIX,
-    RSPRESS_BUNDLER_CONFIG_NAME: ()=>RSPRESS_BUNDLER_CONFIG_NAME,
-    RSPRESS_SSR_DIR: ()=>RSPRESS_SSR_DIR
+  CALL_NAME_MAP: () => (CALL_NAME_MAP),
+  DATA_FETCH_CLIENT_SUFFIX: () => (DATA_FETCH_CLIENT_SUFFIX),
+  DATA_FETCH_IDENTIFIER: () => (DATA_FETCH_IDENTIFIER),
+  DEFAULT_ASSET_PREFIX: () => (DEFAULT_ASSET_PREFIX),
+  RSPRESS_BUNDLER_CONFIG_NAME: () => (RSPRESS_BUNDLER_CONFIG_NAME),
+  RSPRESS_SSG_MD_ENV_NAME: () => (RSPRESS_SSG_MD_ENV_NAME),
+  RSPRESS_SSR_DIR: () => (RSPRESS_SSR_DIR)
 });
 const DEFAULT_ASSET_PREFIX = '/';
 const DATA_FETCH_IDENTIFIER = 'data';
@@ -39,21 +54,19 @@ const CALL_NAME_MAP = {
     RSLIB: 'rslib'
 };
 const RSPRESS_BUNDLER_CONFIG_NAME = 'node';
+const RSPRESS_SSG_MD_ENV_NAME = 'node_md';
 const RSPRESS_SSR_DIR = 'ssr';
+
 exports.CALL_NAME_MAP = __webpack_exports__.CALL_NAME_MAP;
 exports.DATA_FETCH_CLIENT_SUFFIX = __webpack_exports__.DATA_FETCH_CLIENT_SUFFIX;
 exports.DATA_FETCH_IDENTIFIER = __webpack_exports__.DATA_FETCH_IDENTIFIER;
 exports.DEFAULT_ASSET_PREFIX = __webpack_exports__.DEFAULT_ASSET_PREFIX;
 exports.RSPRESS_BUNDLER_CONFIG_NAME = __webpack_exports__.RSPRESS_BUNDLER_CONFIG_NAME;
+exports.RSPRESS_SSG_MD_ENV_NAME = __webpack_exports__.RSPRESS_SSG_MD_ENV_NAME;
 exports.RSPRESS_SSR_DIR = __webpack_exports__.RSPRESS_SSR_DIR;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "CALL_NAME_MAP",
-    "DATA_FETCH_CLIENT_SUFFIX",
-    "DATA_FETCH_IDENTIFIER",
-    "DEFAULT_ASSET_PREFIX",
-    "RSPRESS_BUNDLER_CONFIG_NAME",
-    "RSPRESS_SSR_DIR"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+for(var __webpack_i__ in __webpack_exports__) {
+  if(["CALL_NAME_MAP","DATA_FETCH_CLIENT_SUFFIX","DATA_FETCH_IDENTIFIER","DEFAULT_ASSET_PREFIX","RSPRESS_BUNDLER_CONFIG_NAME","RSPRESS_SSG_MD_ENV_NAME","RSPRESS_SSR_DIR"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/constant.mjs

@@ -1,3 +1,5 @@
+
+;// CONCATENATED MODULE: ./src/constant.ts
 const DEFAULT_ASSET_PREFIX = '/';
 const DATA_FETCH_IDENTIFIER = 'data';
 const DATA_FETCH_CLIENT_SUFFIX = '.client';
@@ -6,5 +8,7 @@ const CALL_NAME_MAP = {
     RSLIB: 'rslib'
 };
 const RSPRESS_BUNDLER_CONFIG_NAME = 'node';
+const RSPRESS_SSG_MD_ENV_NAME = 'node_md';
 const RSPRESS_SSR_DIR = 'ssr';
-export { CALL_NAME_MAP, DATA_FETCH_CLIENT_SUFFIX, DATA_FETCH_IDENTIFIER, DEFAULT_ASSET_PREFIX, RSPRESS_BUNDLER_CONFIG_NAME, RSPRESS_SSR_DIR };
+
+export { CALL_NAME_MAP, DATA_FETCH_CLIENT_SUFFIX, DATA_FETCH_IDENTIFIER, DEFAULT_ASSET_PREFIX, RSPRESS_BUNDLER_CONFIG_NAME, RSPRESS_SSG_MD_ENV_NAME, RSPRESS_SSR_DIR };

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './cli/index';