@rslib/core 0.0.18 → 0.1.1

package/dist/index.js

@@ -3,11 +3,12 @@ import * as __WEBPACK_EXTERNAL_MODULE_node_fs__ from "node:fs";
 import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises__ from "node:fs/promises";
 import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
 import * as __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__ from "../compiled/picocolors/index.js";
-import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_core__ from "@rsbuild/core";
 import * as __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__ from "../compiled/commander/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_core__ from "@rsbuild/core";
 import * as __WEBPACK_EXTERNAL_MODULE_tinyglobby__ from "tinyglobby";
 import * as __WEBPACK_EXTERNAL_MODULE_node_module__ from "node:module";
 import * as __WEBPACK_EXTERNAL_MODULE_module__ from "module";
+import * as __WEBPACK_EXTERNAL_MODULE__compiled_chokidar_index_js__ from "../compiled/chokidar/index.js";
 /**
  * Node.js built-in modules.
  * Copied from https://github.com/webpack/webpack/blob/dd44b206a9c50f4b4cb4d134e1a0bd0387b159a3/lib/node/NodeTargetPlugin.js#L12-L72
@@ -91,6 +92,9 @@ async function calcLongestCommonPath(absPaths) {
     if (stats?.isFile()) lca = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].dirname(lca);
     return lca;
 }
+function getAbsolutePath(base, filepath) {
+    return (0, __WEBPACK_EXTERNAL_MODULE_node_path__.isAbsolute)(filepath) ? filepath : (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(base, filepath);
+}
 const readPackageJson = (rootPath)=>{
     const pkgJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(rootPath, './package.json');
     if (!__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(pkgJsonPath)) {
@@ -118,8 +122,9 @@ function omit(obj, keysObj) {
         return ret;
     }, {});
 }
-function isPluginIncluded(config, pluginName) {
-    return Boolean(config.plugins?.some((plugin)=>{
+function isPluginIncluded(pluginName, plugins) {
+    return Boolean(plugins?.some((plugin)=>{
+        if (Array.isArray(plugin)) return isPluginIncluded(pluginName, plugin);
         if ('object' == typeof plugin && null !== plugin && 'name' in plugin) return plugin.name === pluginName;
         return false;
     }));
@@ -127,13 +132,25 @@ function isPluginIncluded(config, pluginName) {
 function checkMFPlugin(config) {
     if ('mf' !== config.format) return true;
     // https://github.com/module-federation/core/blob/4e5c4b96ee45899f3ba5904b8927768980d5ad0e/packages/rsbuild-plugin/src/cli/index.ts#L17
-    const added = isPluginIncluded(config, 'rsbuild:module-federation-enhanced');
+    const added = isPluginIncluded('rsbuild:module-federation-enhanced', config.plugins);
     if (!added) {
         __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn(`${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__["default"].green('format: "mf"')} should be used with ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__["default"].blue('@module-federation/rsbuild-plugin')}", consider installing and adding it to plugins. Check the documentation (https://module-federation.io/guide/basic/rsbuild.html#rslib-module) to get started with "mf" output.`);
         process.exit(1);
     }
     return added;
 }
+function debounce(func, wait) {
+    let timeoutId = null;
+    return (...args)=>{
+        if (null !== timeoutId) clearTimeout(timeoutId);
+        timeoutId = setTimeout(()=>{
+            func(...args);
+        }, wait);
+    };
+}
+/**
+ * Check if running in a TTY context
+ */ const isTTY = (type = 'stdout')=>('stdin' === type ? process.stdin.isTTY : process.stdout.isTTY) && !process.env.CI;
 // setup the logger level
 if (process.env.DEBUG) __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.level = 'verbose';
 function initNodeEnv() {
@@ -150,7 +167,7 @@ function prepareCli() {
     // Some package managers automatically output a blank line, some do not.
     const { npm_execpath } = process.env;
     if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) console.log();
-    __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.greet(`  Rslib v0.0.18\n`);
+    __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.greet(`  Rslib v0.1.1\n`);
 }
 const DEFAULT_CONFIG_NAME = 'rslib.config';
 const DEFAULT_CONFIG_EXTENSIONS = [
@@ -162,6 +179,10 @@ const DEFAULT_CONFIG_EXTENSIONS = [
     '.cts'
 ];
 const SWC_HELPERS = '@swc/helpers';
+const RSLIB_ENTRY_QUERY = '__rslib_entry__';
+const SHEBANG_PREFIX = '#!';
+const SHEBANG_REGEX = /#!.*[\s\n\r]*$/;
+const REACT_DIRECTIVE_REGEX = /^['"]use (client|server)['"](;?)[\s\n\r]*$/;
 const JS_EXTENSIONS = [
     'js',
     'mjs',
@@ -258,9 +279,9 @@ function cssExternalHandler(request, callback, jsExtension, auto, isStyleRedirec
     }
     return false;
 }
-const cssConfig_pluginName = 'rsbuild:lib-css';
+const PLUGIN_NAME = 'rsbuild:lib-css';
 const pluginLibCss = (rootDir)=>({
-        name: cssConfig_pluginName,
+        name: PLUGIN_NAME,
         setup (api) {
             api.modifyBundlerChain((config, { CHAIN_ID })=>{
                 let isUsingCssExtract = false;
@@ -305,12 +326,14 @@ const composeCssConfig = (rootDir, bundle = true)=>{
         }
     };
 };
-const importMetaUrlShim = `/*#__PURE__*/ (function () {
+// The shim will be injected in PostEntryPlugin.
+const importMetaUrlShim = `const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
   return typeof document === 'undefined'
-    ? new (module.require('url'.replace('', '')).URL)('file:' + __filename).href
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
     : (document.currentScript && document.currentScript.src) ||
       new URL('main.js', document.baseURI).href;
-})()`;
+})();
+`;
 // This Rsbuild plugin will shim `import.meta.url` for CommonJS modules.
 // - Replace `import.meta.url` with `importMetaUrl`.
 // - Inject `importMetaUrl` to the end of the module (can't inject at the beginning because of `"use strict";`).
@@ -321,7 +344,7 @@ const pluginCjsImportMetaUrlShim = ()=>({
             api.modifyEnvironmentConfig((config)=>{
                 config.source.define = {
                     ...config.source.define,
-                    'import.meta.url': importMetaUrlShim
+                    'import.meta.url': '__rslib_import_meta_url__'
                 };
             });
         }
@@ -345,6 +368,125 @@ const pluginEsmRequireShim = ()=>({
             });
         }
     });
+const EntryChunkPlugin_require = (0, __WEBPACK_EXTERNAL_MODULE_node_module__.createRequire)(import.meta.url);
+const EntryChunkPlugin_PLUGIN_NAME = 'rsbuild:lib-entry-chunk';
+const LOADER_NAME = 'rsbuild:lib-entry-module';
+const matchFirstLine = (source, regex)=>{
+    const lineBreakPos = source.match(/(\r\n|\n)/);
+    const firstLineContent = source.slice(0, lineBreakPos?.index);
+    const matched = regex.exec(firstLineContent);
+    if (!matched) return false;
+    return matched[0];
+};
+class EntryChunkPlugin {
+    reactDirectives = {};
+    shebangChmod = 493;
+    shebangEntries = {};
+    shebangInjectedAssets = new Set();
+    enabledImportMetaUrlShim;
+    constructor({ enabledImportMetaUrlShim = true }){
+        this.enabledImportMetaUrlShim = enabledImportMetaUrlShim;
+    }
+    apply(compiler) {
+        compiler.hooks.entryOption.tap(EntryChunkPlugin_PLUGIN_NAME, (_context, entries)=>{
+            for(const name in entries){
+                const entry = entries[name];
+                if (!entry) continue;
+                let first;
+                if (Array.isArray(entry)) first = entry[0];
+                else if (Array.isArray(entry.import)) first = entry.import[0];
+                else if ('string' == typeof entry) first = entry;
+                if ('string' != typeof first) continue;
+                const filename = first.split('?')[0];
+                const isJs = JS_EXTENSIONS_PATTERN.test(filename);
+                if (!isJs) continue;
+                const content = compiler.inputFileSystem.readFileSync(filename, {
+                    encoding: 'utf-8'
+                });
+                // Shebang
+                if (content.startsWith(SHEBANG_PREFIX)) {
+                    const shebangMatch = matchFirstLine(content, SHEBANG_REGEX);
+                    if (shebangMatch) this.shebangEntries[name] = shebangMatch;
+                }
+                // React directive
+                const reactDirective = matchFirstLine(content, REACT_DIRECTIVE_REGEX);
+                if (reactDirective) this.reactDirectives[name] = reactDirective;
+            }
+        });
+        compiler.hooks.thisCompilation.tap(EntryChunkPlugin_PLUGIN_NAME, (compilation)=>{
+            compilation.hooks.chunkAsset.tap(EntryChunkPlugin_PLUGIN_NAME, (chunk, filename)=>{
+                const isJs = JS_EXTENSIONS_PATTERN.test(filename);
+                if (!isJs) return;
+                const name = chunk.name;
+                if (!name) return;
+                const shebangEntry = this.shebangEntries[name];
+                if (shebangEntry) this.shebangEntries[filename] = shebangEntry;
+                const reactDirective = this.reactDirectives[name];
+                if (reactDirective) this.reactDirectives[filename] = reactDirective;
+            });
+        });
+        compiler.hooks.make.tap(EntryChunkPlugin_PLUGIN_NAME, (compilation)=>{
+            compilation.hooks.processAssets.tap(EntryChunkPlugin_PLUGIN_NAME, (assets)=>{
+                if (!this.enabledImportMetaUrlShim) return;
+                const chunkAsset = Object.keys(assets).filter((name)=>JS_EXTENSIONS_PATTERN.test(name));
+                for (const name of chunkAsset)compilation.updateAsset(name, (old)=>{
+                    const oldSource = old.source().toString();
+                    const replaceSource = new __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.sources.ReplaceSource(old);
+                    if (oldSource.startsWith('use strict;') || oldSource.startsWith('"use strict";')) replaceSource.replace(0, 11, `"use strict";\n${importMetaUrlShim}`);
+                    else replaceSource.insert(0, importMetaUrlShim);
+                    return replaceSource;
+                });
+            });
+            compilation.hooks.processAssets.tap({
+                name: EntryChunkPlugin_PLUGIN_NAME,
+                // Just after minify stage, to avoid from being minified.
+                stage: __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING - 1
+            }, (assets)=>{
+                const chunkAsset = Object.keys(assets);
+                for (const name of chunkAsset){
+                    const shebangValue = this.shebangEntries[name];
+                    const reactDirectiveValue = this.reactDirectives[name];
+                    if (shebangValue || reactDirectiveValue) compilation.updateAsset(name, (old)=>{
+                        const replaceSource = new __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.rspack.sources.ReplaceSource(old);
+                        // Shebang
+                        if (shebangValue) {
+                            replaceSource.insert(0, `${shebangValue}\n`);
+                            this.shebangInjectedAssets.add(name);
+                        }
+                        // React directives
+                        if (reactDirectiveValue) replaceSource.insert(0, `${reactDirectiveValue}\n`);
+                        return replaceSource;
+                    });
+                }
+            });
+        });
+        compiler.hooks.assetEmitted.tap(EntryChunkPlugin_PLUGIN_NAME, (file, { targetPath })=>{
+            if (this.shebangInjectedAssets.has(file)) (0, __WEBPACK_EXTERNAL_MODULE_node_fs__.chmodSync)(targetPath, this.shebangChmod);
+        });
+    }
+}
+const entryModuleLoaderRsbuildPlugin = ()=>({
+        name: EntryChunkPlugin_PLUGIN_NAME,
+        setup (api) {
+            api.modifyBundlerChain((config, { CHAIN_ID })=>{
+                config.module.rule(CHAIN_ID.RULE.JS).use(LOADER_NAME).loader(EntryChunkPlugin_require.resolve('./entryModuleLoader.js'));
+            });
+        }
+    });
+const composeEntryChunkConfig = ({ enabledImportMetaUrlShim })=>({
+        plugins: [
+            entryModuleLoaderRsbuildPlugin()
+        ],
+        tools: {
+            rspack: {
+                plugins: [
+                    new EntryChunkPlugin({
+                        enabledImportMetaUrlShim
+                    })
+                ]
+            }
+        }
+    });
 const getDefaultExtension = (options)=>{
     const { format, pkgJson, autoExtension } = options;
     let jsExtension = '.js';
@@ -1305,7 +1447,10 @@ async function loadConfig({ cwd = process.cwd(), path, envMode }) {
         path: configFilePath,
         envMode
     });
-    return content;
+    return {
+        content: content,
+        filePath: configFilePath
+    };
 }
 const composeExternalsWarnConfig = (format, ...externalsArray)=>{
     if ('esm' !== format) return {};
@@ -1564,7 +1709,10 @@ async function createConstantRsbuildConfig() {
             target: 'node',
             filenameHash: false,
             distPath: {
-                js: './'
+                js: './',
+                jsAsync: './',
+                css: './',
+                cssAsync: './'
             }
         }
     });
@@ -1675,9 +1823,9 @@ const composeFormatConfig = ({ format, bundle = true, umdName, pkgJson })=>{
                         },
                         // can not set nodeEnv to false, because mf format should build shared module.
                         // If nodeEnv is false, the process.env.NODE_ENV in third-party packages's will not be replaced
-                        // now we have not provide dev mode for users, so we can always set nodeEnv as 'production'
                         optimization: {
-                            nodeEnv: 'production'
+                            nodeEnv: 'production',
+                            moduleIds: 'deterministic'
                         }
                     }
                 },
@@ -1700,9 +1848,20 @@ const composeShimsConfig = (format, shims)=>{
             require: shims?.esm?.require ?? false
         }
     };
+    const enabledShims = {
+        cjs: 'cjs' === format ? resolvedShims.cjs : {
+            'import.meta.url': false
+        },
+        esm: 'esm' === format ? resolvedShims.esm : {
+            __filename: false,
+            __dirname: false,
+            require: false
+        }
+    };
+    let rsbuildConfig = {};
     switch(format){
         case 'esm':
-            return {
+            rsbuildConfig = {
                 tools: {
                     rspack: {
                         node: {
@@ -1716,19 +1875,24 @@ const composeShimsConfig = (format, shims)=>{
                     resolvedShims.esm.require && pluginEsmRequireShim()
                 ].filter(Boolean)
             };
+            break;
         case 'cjs':
-            return {
+            rsbuildConfig = {
                 plugins: [
                     resolvedShims.cjs['import.meta.url'] && pluginCjsImportMetaUrlShim()
                 ].filter(Boolean)
             };
+            break;
         case 'umd':
-            return {};
         case 'mf':
-            return {};
+            break;
         default:
             throw new Error(`Unsupported format: ${format}`);
     }
+    return {
+        rsbuildConfig,
+        enabledShims
+    };
 };
 const composeModuleImportWarn = (request)=>`The externalized commonjs request ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__["default"].green(`"${request}"`)} will use ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__["default"].blue('"module"')} external type in ESM format. If you want to specify other external type, considering set the request and type with ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__["default"].blue('"output.externals"')}.`;
 const composeExternalsConfig = (format, externals)=>{
@@ -1737,7 +1901,7 @@ const composeExternalsConfig = (format, externals)=>{
     // should to be unified and merged together in the future.
     const externalsTypeMap = {
         esm: 'module-import',
-        cjs: 'commonjs',
+        cjs: 'commonjs-import',
         umd: 'umd',
         // If use 'var', when projects import an external package like '@pkg', this will cause a syntax error such as 'var pkg = @pkg'.
         // If use 'umd', the judgement conditions may be affected by other packages that define variables like 'define'.
@@ -1769,16 +1933,18 @@ const composeAutoExtensionConfig = (config, autoExtension, pkgJson)=>{
         pkgJson,
         autoExtension
     });
-    return {
-        config: {
-            output: {
-                filename: {
-                    js: `[name]${jsExtension}`,
-                    ...config.output?.filename
-                }
+    const updatedConfig = {
+        output: {
+            filename: {
+                js: `[name]${jsExtension}`,
+                ...config.output?.filename
             }
-        },
-        jsExtension,
+        }
+    };
+    const updatedJsExtension = 'string' == typeof updatedConfig.output?.filename?.js && updatedConfig.output?.filename?.js ? (0, __WEBPACK_EXTERNAL_MODULE_node_path__.extname)(updatedConfig.output.filename.js) : jsExtension;
+    return {
+        config: updatedConfig,
+        jsExtension: updatedJsExtension,
         dtsExtension
     };
 };
@@ -1809,6 +1975,18 @@ const composeSyntaxConfig = (target, syntax)=>{
         }
     };
 };
+const appendEntryQuery = (entry)=>{
+    const newEntry = {};
+    for (const [key, value] of Object.entries(entry)){
+        let result = value;
+        result = 'string' == typeof value ? `${value}?${RSLIB_ENTRY_QUERY}` : Array.isArray(value) ? value.map((item)=>`${item}?${RSLIB_ENTRY_QUERY}`) : {
+            ...value,
+            import: 'string' == typeof value.import ? `${value.import}?${RSLIB_ENTRY_QUERY}` : value.import.map((item)=>`${item}?${RSLIB_ENTRY_QUERY}`)
+        };
+        newEntry[key] = result;
+    }
+    return newEntry;
+};
 const composeEntryConfig = async (entries, bundle, root, cssModulesAuto)=>{
     if (!entries) return {
         entryConfig: {},
@@ -1817,7 +1995,7 @@ const composeEntryConfig = async (entries, bundle, root, cssModulesAuto)=>{
     if (false !== bundle) return {
         entryConfig: {
             source: {
-                entry: entries
+                entry: appendEntryQuery(entries)
             }
         },
         lcp: null
@@ -1864,7 +2042,7 @@ const composeEntryConfig = async (entries, bundle, root, cssModulesAuto)=>{
     const lcp = await calcLongestCommonPath(Object.values(resolvedEntries));
     const entryConfig = {
         source: {
-            entry: resolvedEntries
+            entry: appendEntryQuery(resolvedEntries)
         }
     };
     return {
@@ -1897,7 +2075,8 @@ const composeBundleConfig = (jsExtension, redirect, cssModulesAuto, bundle)=>{
                                 if (!JS_EXTENSIONS_PATTERN.test(request)) // If it does not match jsExtensionsPattern, we should do nothing, eg: ./foo.png
                                 return callback();
                                 request = request.replace(/\.[^.]+$/, jsExtension);
-                            } else request = `${request}${jsExtension}`;
+                            } else // TODO: add redirect.extension option
+                            request = `${request}${jsExtension}`;
                         }
                         return callback(null, request);
                     }
@@ -1908,7 +2087,7 @@ const composeBundleConfig = (jsExtension, redirect, cssModulesAuto, bundle)=>{
     };
 };
 const composeDtsConfig = async (libConfig, dtsExtension)=>{
-    const { output, autoExternal, banner, footer } = libConfig;
+    const { autoExternal, banner, footer } = libConfig;
     let { dts } = libConfig;
     if (false === dts || void 0 === dts) return {};
     // DTS default to bundleless whether js is bundle or not
@@ -1920,10 +2099,10 @@ const composeDtsConfig = async (libConfig, dtsExtension)=>{
         plugins: [
             pluginDts({
                 // Only setting ⁠dts.bundle to true will generate the bundled d.ts.
-                bundle: dts?.bundle ?? false,
-                distPath: dts?.distPath ?? output?.distPath?.root ?? './dist',
-                build: dts?.build ?? false,
-                abortOnError: dts?.abortOnError ?? true,
+                bundle: dts?.bundle,
+                distPath: dts?.distPath,
+                build: dts?.build,
+                abortOnError: dts?.abortOnError,
                 dtsExtension: dts?.autoExtension ? dtsExtension : '.d.ts',
                 autoExternal,
                 banner: banner?.dts,
@@ -2010,14 +2189,15 @@ const composeExternalHelpersConfig = (externalHelpers, pkgJson)=>{
     }
     return defaultConfig;
 };
-async function composeLibRsbuildConfig(config, configPath) {
+async function composeLibRsbuildConfig(config) {
     checkMFPlugin(config);
-    const rootPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(configPath);
+    // Get the absolute path of the root directory to align with Rsbuild's default behavior
+    const rootPath = config.root ? getAbsolutePath(process.cwd(), config.root) : process.cwd();
     const pkgJson = readPackageJson(rootPath);
     const { compilerOptions } = await loadTsconfig(rootPath, config.source?.tsconfigPath);
     const cssModulesAuto = config.output?.cssModules?.auto ?? true;
     const { format, shims, bundle = true, banner = {}, footer = {}, autoExtension = true, autoExternal = true, externalHelpers = false, redirect = {}, umdName } = config;
-    const shimsConfig = composeShimsConfig(format, shims);
+    const { rsbuildConfig: shimsConfig, enabledShims } = composeShimsConfig(format, shims);
     const formatConfig = composeFormatConfig({
         format: format,
         pkgJson: pkgJson,
@@ -2035,25 +2215,27 @@ async function composeLibRsbuildConfig(config, configPath) {
         pkgJson,
         userExternals: config.output?.externals
     });
-    const { entryConfig, lcp } = await composeEntryConfig(config.source?.entry, config.bundle, (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(configPath), cssModulesAuto);
+    const { entryConfig, lcp } = await composeEntryConfig(config.source?.entry, config.bundle, rootPath, cssModulesAuto);
     const cssConfig = composeCssConfig(lcp, config.bundle);
+    const entryChunkConfig = composeEntryChunkConfig({
+        enabledImportMetaUrlShim: enabledShims.cjs['import.meta.url']
+    });
     const dtsConfig = await composeDtsConfig(config, dtsExtension);
     const externalsWarnConfig = composeExternalsWarnConfig(format, autoExternalConfig?.output?.externals, externalsConfig?.output?.externals);
     const minifyConfig = composeMinifyConfig(config);
     const bannerFooterConfig = composeBannerFooterConfig(banner, footer);
     const decoratorsConfig = composeDecoratorsConfig(compilerOptions, config.source?.decorators?.version);
-    return (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.mergeRsbuildConfig)(formatConfig, shimsConfig, externalHelpersConfig, externalsWarnConfig, externalsConfig, autoExternalConfig, autoExtensionConfig, syntaxConfig, bundleConfig, targetConfig, entryConfig, cssConfig, minifyConfig, dtsConfig, bannerFooterConfig, decoratorsConfig);
+    return (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.mergeRsbuildConfig)(formatConfig, shimsConfig, externalHelpersConfig, externalsWarnConfig, externalsConfig, autoExternalConfig, autoExtensionConfig, syntaxConfig, bundleConfig, targetConfig, entryConfig, cssConfig, entryChunkConfig, minifyConfig, dtsConfig, bannerFooterConfig, decoratorsConfig);
 }
-async function composeCreateRsbuildConfig(rslibConfig, path) {
+async function composeCreateRsbuildConfig(rslibConfig) {
     const constantRsbuildConfig = await createConstantRsbuildConfig();
-    const configPath = path ?? rslibConfig._privateMeta?.configFilePath;
     const { lib: libConfigsArray, ...sharedRsbuildConfig } = rslibConfig;
     if (!libConfigsArray) throw new Error(`Expect lib field to be an array, but got ${libConfigsArray}.`);
     const libConfigPromises = libConfigsArray.map(async (libConfig)=>{
         const userConfig = (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.mergeRsbuildConfig)(sharedRsbuildConfig, libConfig);
         // Merge the configuration of each environment based on the shared Rsbuild
         // configuration and Lib configuration in the settings.
-        const libRsbuildConfig = await composeLibRsbuildConfig(userConfig, configPath);
+        const libRsbuildConfig = await composeLibRsbuildConfig(userConfig);
         // Reset certain fields because they will be completely overridden by the upcoming merge.
         // We don't want to retain them in the final configuration.
         // The reset process should occur after merging the library configuration.
@@ -2062,7 +2244,7 @@ async function composeCreateRsbuildConfig(rslibConfig, path) {
         // Already manually sort and merge the externals configuration.
         userConfig.output ??= {};
         delete userConfig.output.externals;
-        return {
+        const config = {
             format: libConfig.format,
             // The merge order represents the priority of the configuration
             // The priorities from high to low are as follows:
@@ -2073,6 +2255,7 @@ async function composeCreateRsbuildConfig(rslibConfig, path) {
             // In compose process of 2, we may read some config from 1, and reassemble the related config,
             // so before final mergeRsbuildConfig, we reset some specified fields
             config: (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.mergeRsbuildConfig)(constantRsbuildConfig, libRsbuildConfig, omit(userConfig, {
+                id: true,
                 bundle: true,
                 format: true,
                 autoExtension: true,
@@ -2087,43 +2270,117 @@ async function composeCreateRsbuildConfig(rslibConfig, path) {
                 umdName: true
             }))
         };
+        if ('string' == typeof libConfig.id) config.id = libConfig.id;
+        return config;
     });
     const composedRsbuildConfig = await Promise.all(libConfigPromises);
     return composedRsbuildConfig;
 }
 async function composeRsbuildEnvironments(rslibConfig) {
-    const rsbuildConfigObject = await composeCreateRsbuildConfig(rslibConfig);
+    const rsbuildConfigWithLibInfo = await composeCreateRsbuildConfig(rslibConfig);
+    // User provided ids should take precedence over generated ids.
+    const usedIds = rsbuildConfigWithLibInfo.map(({ id })=>id).filter(Boolean);
     const environments = {};
-    const formatCount = rsbuildConfigObject.reduce((acc, { format })=>{
+    const formatCount = rsbuildConfigWithLibInfo.reduce((acc, { format })=>{
         acc[format] = (acc[format] ?? 0) + 1;
         return acc;
     }, {});
-    const formatIndex = {
-        esm: 0,
-        cjs: 0,
-        umd: 0,
-        mf: 0
+    const composeDefaultId = (format)=>{
+        const nextDefaultId = (format, index)=>`${format}${1 === formatCount[format] && 0 === index ? '' : index}`;
+        let index = 0;
+        let candidateId = nextDefaultId(format, index);
+        while(-1 !== usedIds.indexOf(candidateId))candidateId = nextDefaultId(format, ++index);
+        usedIds.push(candidateId);
+        return candidateId;
     };
-    for (const { format, config } of rsbuildConfigObject){
-        const currentFormatCount = formatCount[format];
-        const currentFormatIndex = formatIndex[format]++;
-        environments[1 === currentFormatCount ? format : `${format}${currentFormatIndex}`] = config;
+    for (const { format, id, config } of rsbuildConfigWithLibInfo){
+        const libId = 'string' == typeof id ? id : composeDefaultId(format);
+        environments[libId] = config;
     }
+    const conflictIds = usedIds.filter((id, index)=>usedIds.indexOf(id) !== index);
+    if (conflictIds.length) throw new Error(`The following ids are duplicated: ${conflictIds.map((id)=>`"${id}"`).join(', ')}. Please change the "lib.id" to be unique.`);
     return environments;
 }
 const pruneEnvironments = (environments, libs)=>{
     if (!libs) return environments;
     return Object.fromEntries(Object.entries(environments).filter(([name])=>libs.includes(name)));
 };
-async function build(config, options) {
+async function watchFilesForRestart(files, restart) {
+    if (!files.length) return;
+    const watcher = __WEBPACK_EXTERNAL_MODULE__compiled_chokidar_index_js__["default"].watch(files, {
+        ignoreInitial: true,
+        // If watching fails due to read permissions, the errors will be suppressed silently.
+        ignorePermissionErrors: true,
+        ignored: [
+            '**/node_modules/**',
+            '**/.git/**',
+            '**/.DS_Store/**'
+        ]
+    });
+    const callback = debounce(async (filePath)=>{
+        watcher.close();
+        await beforeRestart({
+            filePath
+        });
+        await restart();
+    }, 300);
+    watcher.on('add', callback);
+    watcher.on('change', callback);
+    watcher.on('unlink', callback);
+}
+let cleaners = [];
+/**
+ * Add a cleaner to handle side effects
+ */ const onBeforeRestart = (cleaner)=>{
+    cleaners.push(cleaner);
+};
+const clearConsole = ()=>{
+    if (isTTY() && !process.env.DEBUG) process.stdout.write('\x1B[H\x1B[2J');
+};
+const beforeRestart = async ({ filePath, clear = true } = {})=>{
+    if (clear) clearConsole();
+    if (filePath) {
+        const filename = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].basename(filePath);
+        __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.info(`Restart because ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__["default"].yellow(filename)} is changed.\n`);
+    } else __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.info('Restarting...\n');
+    for (const cleaner of cleaners)await cleaner();
+    cleaners = [];
+};
+async function build(config, options = {}) {
     const environments = await composeRsbuildEnvironments(config);
     const rsbuildInstance = await (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.createRsbuild)({
         rsbuildConfig: {
-            environments: pruneEnvironments(environments, options?.lib)
+            environments: pruneEnvironments(environments, options.lib)
         }
     });
-    await rsbuildInstance.build({
-        watch: options?.watch
+    const buildInstance = await rsbuildInstance.build({
+        watch: options.watch
+    });
+    if (options.watch) onBeforeRestart(buildInstance.close);
+    else await buildInstance.close();
+    return rsbuildInstance;
+}
+async function loadRslibConfig(options) {
+    const cwd = process.cwd();
+    const root = options.root ? getAbsolutePath(cwd, options.root) : cwd;
+    return loadConfig({
+        cwd: root,
+        path: options.config,
+        envMode: options.envMode
+    });
+}
+async function inspect(config, options = {}) {
+    const environments = await composeRsbuildEnvironments(config);
+    const rsbuildInstance = await (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.createRsbuild)({
+        rsbuildConfig: {
+            environments: pruneEnvironments(environments, options.lib)
+        }
+    });
+    await rsbuildInstance.inspectConfig({
+        mode: options.mode,
+        verbose: options.verbose,
+        outputPath: options.output,
+        writeToDisk: true
     });
     return rsbuildInstance;
 }
@@ -2140,7 +2397,8 @@ async function initMFRsbuild(rslibConfig) {
     const rsbuildInstance = await (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.createRsbuild)({
         rsbuildConfig: mfRsbuildConfig.config
     });
-    await rsbuildInstance.startDevServer();
+    const devServer = await rsbuildInstance.startDevServer();
+    onBeforeRestart(devServer.server.close);
     return rsbuildInstance;
 }
 function changeEnvToDev(rsbuildConfig) {
@@ -2152,20 +2410,21 @@ function changeEnvToDev(rsbuildConfig) {
         tools: {
             rspack: {
                 optimization: {
-                    nodeEnv: 'development'
+                    nodeEnv: 'development',
+                    moduleIds: 'named'
                 }
             }
         }
     });
 }
 const applyCommonOptions = (command)=>{
-    command.option('-c --config <config>', 'specify the configuration file, can be a relative or absolute path').option('--env-mode <mode>', 'specify the env mode to load the `.env.[mode]` file');
+    command.option('-c --config <config>', 'specify the configuration file, can be a relative or absolute path').option('-r --root <root>', 'specify the project root directory, can be an absolute path or a path relative to cwd').option('--env-mode <mode>', 'specify the env mode to load the `.env.[mode]` file');
 };
 const repeatableOption = (value, previous)=>(previous ?? []).concat([
         value
     ]);
 function runCli() {
-    __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.name('rslib').usage('<command> [options]').version("0.0.18");
+    __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.name('rslib').usage('<command> [options]').version("0.1.1");
     const buildCommand = __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.command('build');
     const inspectCommand = __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.command('inspect');
     const mfDevCommand = __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.command('mf dev');
@@ -2174,37 +2433,33 @@ function runCli() {
         inspectCommand,
         mfDevCommand
     ].forEach(applyCommonOptions);
-    buildCommand.option('--lib <name>', 'build the specified library (may be repeated)', repeatableOption).option('-w --watch', 'turn on watch mode, watch for changes and rebuild').description('build the library for production').action(async (options)=>{
+    buildCommand.option('--lib <id>', 'build the specified library (may be repeated)', repeatableOption).option('-w --watch', 'turn on watch mode, watch for changes and rebuild').description('build the library for production').action(async (options)=>{
         try {
-            const rslibConfig = await loadConfig({
-                path: options.config,
-                envMode: options.envMode
-            });
-            await build(rslibConfig, options);
+            const cliBuild = async ()=>{
+                const { content: rslibConfig, filePath } = await loadRslibConfig(options);
+                await build(rslibConfig, options);
+                if (options.watch) watchFilesForRestart([
+                    filePath
+                ], async ()=>{
+                    await cliBuild();
+                });
+            };
+            await cliBuild();
         } catch (err) {
             __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.error('Failed to build.');
             __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.error(err);
             process.exit(1);
         }
     });
-    inspectCommand.description('inspect the Rsbuild / Rspack configs of Rslib projects').option('--lib <name>', 'inspect the specified library (may be repeated)', repeatableOption).option('--output <output>', 'specify inspect content output path', '.rsbuild').option('--verbose', 'show full function definitions in output').action(async (options)=>{
+    inspectCommand.description('inspect the Rsbuild / Rspack configs of Rslib projects').option('--lib <id>', 'inspect the specified library (may be repeated)', repeatableOption).option('--output <output>', 'specify inspect content output path', '.rsbuild').option('--verbose', 'show full function definitions in output').action(async (options)=>{
         try {
             // TODO: inspect should output Rslib's config
-            const rslibConfig = await loadConfig({
-                path: options.config,
-                envMode: options.envMode
-            });
-            const environments = await composeRsbuildEnvironments(rslibConfig);
-            const rsbuildInstance = await (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.createRsbuild)({
-                rsbuildConfig: {
-                    environments: pruneEnvironments(environments, options.lib)
-                }
-            });
-            await rsbuildInstance.inspectConfig({
+            const { content: rslibConfig } = await loadRslibConfig(options);
+            await inspect(rslibConfig, {
+                lib: options.lib,
                 mode: options.mode,
-                verbose: options.verbose,
-                outputPath: options.output,
-                writeToDisk: true
+                output: options.output,
+                verbose: options.verbose
             });
         } catch (err) {
             __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.error('Failed to inspect config.');
@@ -2214,11 +2469,17 @@ function runCli() {
     });
     mfDevCommand.description('start Rsbuild dev server of Module Federation format').action(async (options)=>{
         try {
-            const rslibConfig = await loadConfig({
-                path: options.config,
-                envMode: options.envMode
-            });
-            await startMFDevServer(rslibConfig);
+            const cliMfDev = async ()=>{
+                const { content: rslibConfig, filePath } = await loadRslibConfig(options);
+                // TODO: support lib option in mf dev server
+                await startMFDevServer(rslibConfig);
+                watchFilesForRestart([
+                    filePath
+                ], async ()=>{
+                    await cliMfDev();
+                });
+            };
+            await cliMfDev();
         } catch (err) {
             __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.error('Failed to start mf dev.');
             __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.error(err);
@@ -2227,6 +2488,6 @@ function runCli() {
     });
     __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.parse();
 }
-const src_version = "0.0.18";
+const src_rslib_entry_version = "0.1.1";
 var __webpack_exports__logger = __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger;
-export { build, defineConfig, loadConfig, prepareCli, runCli, composeCreateRsbuildConfig as unstable_composeCreateRsbuildConfig, src_version as version, __webpack_exports__logger as logger };
+export { build, defineConfig, inspect, loadConfig, prepareCli, runCli, startMFDevServer, composeCreateRsbuildConfig as unstable_composeCreateRsbuildConfig, src_rslib_entry_version as version, __webpack_exports__logger as logger };