@rslib/core 0.0.17 → 0.1.0

package/dist/entryModuleLoader.js

@@ -0,0 +1,53 @@
+const RSLIB_ENTRY_QUERY = '__rslib_entry__';
+const SHEBANG_REGEX = /#!.*[\s\n\r]*$/;
+const REACT_DIRECTIVE_REGEX = /^['"]use (client|server)['"](;?)[\s\n\r]*$/;
+const JS_EXTENSIONS = [
+    'js',
+    'mjs',
+    'jsx',
+    'ts',
+    'mts',
+    'tsx',
+    'cjs',
+    'cjsx',
+    'mjsx',
+    'mtsx',
+    'cts',
+    'ctsx'
+];
+const CSS_EXTENSIONS = [
+    'css',
+    'sass',
+    'scss',
+    'less'
+];
+const ENTRY_EXTENSIONS = [
+    ...JS_EXTENSIONS,
+    ...CSS_EXTENSIONS
+];
+new RegExp(`\\.(${JS_EXTENSIONS.join('|')})$`);
+new RegExp(`\\.(${CSS_EXTENSIONS.join('|')})$`);
+new RegExp(`\\.(${ENTRY_EXTENSIONS.join('|')})$`);
+function splitFromFirstLine(text) {
+    const match = text.match(/(\r\n|\n)/);
+    if (!match) return [
+        text,
+        ''
+    ];
+    return [
+        text.slice(0, match.index),
+        text.slice(match.index)
+    ];
+}
+const entryModuleLoader_loader = function(source) {
+    let result = source;
+    if (this.resourceQuery === `?${RSLIB_ENTRY_QUERY}`) {
+        const [firstLine1, rest] = splitFromFirstLine(result);
+        if (SHEBANG_REGEX.test(firstLine1)) result = rest;
+        const [firstLine2, rest2] = splitFromFirstLine(result);
+        if (REACT_DIRECTIVE_REGEX.test(firstLine2)) result = rest2;
+    }
+    return result;
+};
+/* ESM default export */ const entryModuleLoader = entryModuleLoader_loader;
+export { entryModuleLoader as default };

package/dist/index.js

@@ -3,8 +3,8 @@ 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";
@@ -91,6 +91,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 +121,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,7 +131,7 @@ 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);
@@ -150,7 +154,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.17\n`);
+    __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.greet(`  Rslib v0.1.0\n`);
 }
 const DEFAULT_CONFIG_NAME = 'rslib.config';
 const DEFAULT_CONFIG_EXTENSIONS = [
@@ -162,6 +166,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 +266,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 +313,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 +331,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 +355,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';
@@ -1564,7 +1693,10 @@ async function createConstantRsbuildConfig() {
             target: 'node',
             filenameHash: false,
             distPath: {
-                js: './'
+                js: './',
+                jsAsync: './',
+                css: './',
+                cssAsync: './'
             }
         }
     });
@@ -1673,7 +1805,6 @@ const composeFormatConfig = ({ format, bundle = true, umdName, pkgJson })=>{
                         output: {
                             uniqueName: pkgJson.name
                         },
-                        // TODO when we provide dev mode for rslib mf format, this should be modified to as the same with config.mode
                         // 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'
@@ -1681,6 +1812,9 @@ const composeFormatConfig = ({ format, bundle = true, umdName, pkgJson })=>{
                             nodeEnv: 'production'
                         }
                     }
+                },
+                output: {
+                    target: 'web'
                 }
             };
         default:
@@ -1698,9 +1832,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: {
@@ -1714,19 +1859,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)=>{
@@ -1735,7 +1885,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'.
@@ -1767,16 +1917,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
     };
 };
@@ -1807,6 +1959,11 @@ const composeSyntaxConfig = (target, syntax)=>{
         }
     };
 };
+const appendEntryQuery = (entry)=>{
+    const newEntry = {};
+    for(const key in entry)newEntry[key] = `${entry[key]}?${RSLIB_ENTRY_QUERY}`;
+    return newEntry;
+};
 const composeEntryConfig = async (entries, bundle, root, cssModulesAuto)=>{
     if (!entries) return {
         entryConfig: {},
@@ -1815,7 +1972,7 @@ const composeEntryConfig = async (entries, bundle, root, cssModulesAuto)=>{
     if (false !== bundle) return {
         entryConfig: {
             source: {
-                entry: entries
+                entry: appendEntryQuery(entries)
             }
         },
         lcp: null
@@ -1862,7 +2019,7 @@ const composeEntryConfig = async (entries, bundle, root, cssModulesAuto)=>{
     const lcp = await calcLongestCommonPath(Object.values(resolvedEntries));
     const entryConfig = {
         source: {
-            entry: resolvedEntries
+            entry: appendEntryQuery(resolvedEntries)
         }
     };
     return {
@@ -1895,7 +2052,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);
                     }
@@ -1906,7 +2064,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
@@ -1918,10 +2076,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,
@@ -1930,8 +2088,10 @@ const composeDtsConfig = async (libConfig, dtsExtension)=>{
         ]
     };
 };
-const composeTargetConfig = (target = 'node')=>{
-    switch(target){
+const composeTargetConfig = (target, format)=>{
+    let defaultTarget = target;
+    if (!defaultTarget) defaultTarget = 'mf' === format ? 'web' : 'node';
+    switch(defaultTarget){
         case 'web':
             return {
                 config: {
@@ -1975,7 +2135,7 @@ const composeTargetConfig = (target = 'node')=>{
         //     },
         //   };
         default:
-            throw new Error(`Unsupported platform: ${target}`);
+            throw new Error(`Unsupported platform: ${defaultTarget}`);
     }
 };
 const composeExternalHelpersConfig = (externalHelpers, pkgJson)=>{
@@ -2006,14 +2166,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,
@@ -2024,32 +2185,34 @@ async function composeLibRsbuildConfig(config, configPath) {
     const externalsConfig = composeExternalsConfig(format, config.output?.externals);
     const { config: autoExtensionConfig, jsExtension, dtsExtension } = composeAutoExtensionConfig(config, autoExtension, pkgJson);
     const bundleConfig = composeBundleConfig(jsExtension, redirect, cssModulesAuto, bundle);
-    const { config: targetConfig, target } = composeTargetConfig(config.output?.target);
+    const { config: targetConfig, target } = composeTargetConfig(config.output?.target, format);
     const syntaxConfig = composeSyntaxConfig(target, config?.syntax);
     const autoExternalConfig = composeAutoExternalConfig({
         autoExternal,
         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.
@@ -2058,7 +2221,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:
@@ -2069,6 +2232,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,
@@ -2083,43 +2247,75 @@ 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 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
+        watch: options.watch
+    });
+    return rsbuildInstance;
+}
+async function loadRslibConfig(options) {
+    const cwd = process.cwd();
+    const root = options.root ? getAbsolutePath(cwd, options.root) : cwd;
+    const rslibConfig = await loadConfig({
+        cwd: root,
+        path: options.config,
+        envMode: options.envMode
+    });
+    return rslibConfig;
+}
+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;
 }
@@ -2155,13 +2351,13 @@ function changeEnvToDev(rsbuildConfig) {
     });
 }
 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.17");
+    __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.name('rslib').usage('<command> [options]').version("0.1.0");
     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');
@@ -2170,37 +2366,28 @@ 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
+            const rslibConfig = await loadRslibConfig(options);
+            await build(rslibConfig, {
+                lib: options.lib,
+                watch: options.watch
             });
-            await build(rslibConfig, options);
         } 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 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.');
@@ -2210,10 +2397,8 @@ 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
-            });
+            const rslibConfig = await loadRslibConfig(options);
+            // TODO: support lib option in mf dev server
             await startMFDevServer(rslibConfig);
         } catch (err) {
             __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.error('Failed to start mf dev.');
@@ -2223,6 +2408,6 @@ function runCli() {
     });
     __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.parse();
 }
-const src_version = "0.0.17";
+const src_version = "0.1.0";
 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_version as version, __webpack_exports__logger as logger };

package/dist-types/cli/build.d.ts

@@ -0,0 +1,4 @@
+import { type RsbuildInstance } from '@rsbuild/core';
+import type { RslibConfig } from '../types/config';
+import type { BuildOptions } from './commands';
+export declare function build(config: RslibConfig, options?: Pick<BuildOptions, 'lib' | 'watch'>): Promise<RsbuildInstance>;

package/dist-types/cli/commands.d.ts

@@ -1,5 +1,6 @@
-import { type RsbuildMode } from '@rsbuild/core';
+import type { RsbuildMode } from '@rsbuild/core';
 export type CommonOptions = {
+    root?: string;
     config?: string;
     envMode?: string;
     lib?: string[];
@@ -8,8 +9,8 @@ export type BuildOptions = CommonOptions & {
     watch?: boolean;
 };
 export type InspectOptions = CommonOptions & {
-    mode: RsbuildMode;
-    output: string;
+    mode?: RsbuildMode;
+    output?: string;
     verbose?: boolean;
 };
 export declare function runCli(): void;

package/dist-types/cli/init.d.ts

@@ -0,0 +1,3 @@
+import type { RslibConfig } from '../types';
+import type { CommonOptions } from './commands';
+export declare function loadRslibConfig(options: CommonOptions): Promise<RslibConfig>;

package/dist-types/cli/inspect.d.ts

@@ -0,0 +1,4 @@
+import { type RsbuildInstance } from '@rsbuild/core';
+import type { RslibConfig } from '../types/config';
+import type { InspectOptions } from './commands';
+export declare function inspect(config: RslibConfig, options?: Pick<InspectOptions, 'lib' | 'mode' | 'output' | 'verbose'>): Promise<RsbuildInstance>;

package/dist-types/{mf.d.ts → cli/mf.d.ts}

@@ -1,3 +1,3 @@
 import type { RsbuildInstance } from '@rsbuild/core';
-import type { RslibConfig } from './types';
+import type { RslibConfig } from '../types';
 export declare function startMFDevServer(config: RslibConfig): Promise<RsbuildInstance | undefined>;

package/dist-types/config.d.ts

@@ -1,5 +1,5 @@
 import { type EnvironmentConfig, type RsbuildConfig } from '@rsbuild/core';
-import type { AutoExternal, BannerAndFooter, Format, LibConfig, PkgJson, RslibConfig, RslibConfigAsyncFn, RslibConfigExport, RslibConfigSyncFn } from './types';
+import type { AutoExternal, BannerAndFooter, LibConfig, PkgJson, RsbuildConfigWithLibInfo, RslibConfig, RslibConfigAsyncFn, RslibConfigExport, RslibConfigSyncFn } from './types';
 /**
  * This function helps you to autocomplete configuration types.
  * It accepts a Rslib config object, or a function that returns a config.
@@ -23,9 +23,6 @@ export declare function composeBannerFooterConfig(banner: BannerAndFooter, foote
 export declare function composeDecoratorsConfig(compilerOptions?: Record<string, any>, version?: NonNullable<NonNullable<RsbuildConfig['source']>['decorators']>['version']): RsbuildConfig;
 export declare function createConstantRsbuildConfig(): Promise<RsbuildConfig>;
 export declare const composeModuleImportWarn: (request: string) => string;
-export declare function composeCreateRsbuildConfig(rslibConfig: RslibConfig, path?: string): Promise<{
-    format: Format;
-    config: RsbuildConfig;
-}[]>;
+export declare function composeCreateRsbuildConfig(rslibConfig: RslibConfig): Promise<RsbuildConfigWithLibInfo[]>;
 export declare function composeRsbuildEnvironments(rslibConfig: RslibConfig): Promise<Record<string, EnvironmentConfig>>;
 export declare const pruneEnvironments: (environments: Record<string, EnvironmentConfig>, libs?: string[]) => Record<string, EnvironmentConfig>;

package/dist-types/constant.d.ts

@@ -1,6 +1,10 @@
 export declare const DEFAULT_CONFIG_NAME = "rslib.config";
 export declare const DEFAULT_CONFIG_EXTENSIONS: readonly [".js", ".ts", ".mjs", ".mts", ".cjs", ".cts"];
 export declare const SWC_HELPERS = "@swc/helpers";
+export declare const RSLIB_ENTRY_QUERY = "__rslib_entry__";
+export declare const SHEBANG_PREFIX = "#!";
+export declare const SHEBANG_REGEX: RegExp;
+export declare const REACT_DIRECTIVE_REGEX: RegExp;
 export declare const JS_EXTENSIONS: string[];
 export declare const CSS_EXTENSIONS: string[];
 export declare const ENTRY_EXTENSIONS: string[];

package/dist-types/css/RemoveCssExtractAssetPlugin.d.ts

@@ -1,11 +1,11 @@
-import type { Compiler, RspackPluginInstance } from '@rspack/core';
+import type { Rspack } from '@rsbuild/core';
 type Options = {
     include: RegExp;
 };
-declare class RemoveCssExtractAssetPlugin implements RspackPluginInstance {
+declare class RemoveCssExtractAssetPlugin implements Rspack.RspackPluginInstance {
     readonly name: string;
     options: Options;
     constructor(options: Options);
-    apply(compiler: Compiler): void;
+    apply(compiler: Rspack.Compiler): void;
 }
 export { RemoveCssExtractAssetPlugin };

package/dist-types/css/libCssExtractLoader.d.ts

@@ -1,4 +1,4 @@
-import type { LoaderDefinition } from '@rspack/core';
+import type { Rspack } from '@rsbuild/core';
 export interface CssExtractRspackLoaderOptions {
     emit?: boolean;
     esModule?: boolean;
@@ -6,6 +6,6 @@ export interface CssExtractRspackLoaderOptions {
     defaultExport?: boolean;
     rootDir?: string;
 }
-declare const loader: LoaderDefinition;
-export declare const pitch: LoaderDefinition['pitch'];
+declare const loader: Rspack.LoaderDefinition;
+export declare const pitch: Rspack.LoaderDefinition['pitch'];
 export default loader;

package/dist-types/index.d.ts

@@ -1,7 +1,9 @@
 export { prepareCli } from './cli/prepare';
 export { runCli } from './cli/commands';
+export { build } from './cli/build';
+export { inspect } from './cli/inspect';
+export { startMFDevServer } from './cli/mf';
 export { defineConfig, loadConfig, composeCreateRsbuildConfig as unstable_composeCreateRsbuildConfig, } from './config';
-export { build } from './build';
 export { logger } from './utils/logger';
 export type * from './types';
 export declare const version: string;

package/dist-types/plugins/EntryChunkPlugin.d.ts

@@ -0,0 +1,4 @@
+import { type RsbuildConfig } from '@rsbuild/core';
+export declare const composeEntryChunkConfig: ({ enabledImportMetaUrlShim, }: {
+    enabledImportMetaUrlShim: boolean;
+}) => RsbuildConfig;

package/dist-types/plugins/entryModuleLoader.d.ts

@@ -0,0 +1,3 @@
+import type { Rspack } from '@rsbuild/core';
+declare const loader: Rspack.LoaderDefinition;
+export default loader;

package/dist-types/plugins/shims.d.ts

@@ -1,3 +1,4 @@
 import { type RsbuildPlugin } from '@rsbuild/core';
+export declare const importMetaUrlShim = "const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {\n  return typeof document === 'undefined'\n    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href\n    : (document.currentScript && document.currentScript.src) ||\n      new URL('main.js', document.baseURI).href;\n})();\n";
 export declare const pluginCjsImportMetaUrlShim: () => RsbuildPlugin;
 export declare const pluginEsmRequireShim: () => RsbuildPlugin;

package/dist-types/types/config/index.d.ts

@@ -4,6 +4,11 @@ export type Format = 'esm' | 'cjs' | 'umd' | 'mf';
 export type FixedEcmaVersions = 'es5' | 'es6' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'es2023';
 export type LatestEcmaVersions = 'es2024' | 'esnext';
 export type EcmaScriptVersion = FixedEcmaVersions | LatestEcmaVersions;
+export type RsbuildConfigWithLibInfo = {
+    id?: string;
+    format: Format;
+    config: RsbuildConfig;
+};
 export type RsbuildConfigOutputTarget = NonNullable<RsbuildConfig['output']>['target'];
 export type Syntax = EcmaScriptVersion | string[];
 export type Dts = (Pick<PluginDtsOptions, 'bundle' | 'distPath' | 'abortOnError' | 'build'> & {
@@ -34,56 +39,70 @@ export type Redirect = {
     style?: boolean;
 };
 export interface LibConfig extends RsbuildConfig {
+    /**
+     * The unique identifier of the library.
+     * @defaultValue `undefined`
+     * @see {@link https://lib.rsbuild.dev/config/lib/id}
+     */
+    id?: string;
     /**
      * Output format for the generated JavaScript files.
-     * @default undefined
+     * @defaultValue `undefined`
+     * @see {@link https://lib.rsbuild.dev/config/lib/format}
      */
     format?: Format;
     /**
      * Whether to bundle the library.
-     * @default true
+     * @defaultValue `true`
+     * @see {@link https://lib.rsbuild.dev/config/lib/bundle}
      */
     bundle?: boolean;
     /**
-     * Whether to automatically set the file extension based on the `format` option in the JavaScript output files.
-     * @default true
+     * Whether to automatically set the file extension based on {@link format} option in the JavaScript output files.
+     * @defaultValue `true`
+     * @see {@link https://lib.rsbuild.dev/config/lib/auto-extension}
      */
     autoExtension?: boolean;
     /**
      * Whether to automatically externalize dependencies of different dependency types and do not bundle them.
-     * @default true
+     * @defaultValue `true`
+     * @see {@link https://lib.rsbuild.dev/config/lib/auto-external}
      */
     autoExternal?: AutoExternal;
     /**
-     * Configure the redirect of the import paths, applicable when `bundle: false`.
-     * @default {}
+     * Configure the redirect of the import paths, applicable {@link bundle} is set to `false`.
+     * @defaultValue `{}`
+     * @see {@link https://lib.rsbuild.dev/config/lib/redirect}
      */
     redirect?: Redirect;
     /**
      * Configure the syntax to which JavaScript and CSS will be downgraded.
-     * Support ECMAScript version and browserslist query.
-     * @default 'esnext'
+     * @defaultValue `'esnext'`
+     * @see {@link https://lib.rsbuild.dev/config/lib/syntax}
      */
     syntax?: Syntax;
     /**
      * Whether to import SWC helper functions from `@swc/helpers` instead of inlining them.
-     * @default false
+     * @defaultValue `false`
+     * @see {@link https://lib.rsbuild.dev/config/lib/external-helpers}
      */
     externalHelpers?: boolean;
     /**
      * Inject content into the top of each JS, CSS or DTS file.
-     * @default {}
+     * @defaultValue `{}`
+     * @see {@link https://lib.rsbuild.dev/config/lib/banner}
      */
     banner?: BannerAndFooter;
     /**
      * Inject content into the bottom of each JS, CSS or DTS file.
-     * @default {}
+     * @defaultValue `{}`
+     * @see {@link https://lib.rsbuild.dev/config/lib/footer}
      */
     footer?: BannerAndFooter;
     /**
      * Configure the shims for CommonJS and ESM output.
      *
-     * @default
+     * @defaultValue
      * ```js
      * const defaultShims = {
      *   cjs: {
@@ -96,16 +115,19 @@ export interface LibConfig extends RsbuildConfig {
      *   },
      * };
      * ```
+     * @see {@link https://lib.rsbuild.dev/config/lib/shims}
      */
     shims?: Shims;
     /**
      * Configure the generation of the TypeScript declaration files.
-     * @default false
+     * @defaultValue `false`
+     * @see {@link https://lib.rsbuild.dev/config/lib/dts}
      */
     dts?: Dts;
     /**
      * The export name of the UMD bundle.
-     * @default undefined
+     * @defaultValue `undefined`
+     * @see {@link https://lib.rsbuild.dev/config/lib/umd-name}
      */
     umdName?: string;
 }

package/dist-types/types/utils.d.ts

@@ -6,3 +6,7 @@ export type PkgJson = {
     devDependencies?: Record<string, string>;
     optionalDependencies?: Record<string, string>;
 };
+export type DeepRequired<T> = Required<{
+    [K in keyof T]: T[K] extends Required<T[K]> ? T[K] : DeepRequired<T[K]>;
+}>;
+export type ExcludesFalse = <T>(x: T | false | undefined | null) => x is T;

package/dist-types/utils/helper.d.ts

@@ -1,3 +1,4 @@
+import type { RsbuildPlugins } from '@rsbuild/core';
 import color from 'picocolors';
 import type { LibConfig, PkgJson } from '../types';
 /**
@@ -6,11 +7,12 @@ import type { LibConfig, PkgJson } from '../types';
  */
 export declare const nodeBuiltInModules: Array<string | RegExp>;
 export declare function calcLongestCommonPath(absPaths: string[]): Promise<string | null>;
+export declare function getAbsolutePath(base: string, filepath: string): string;
 export declare const readPackageJson: (rootPath: string) => undefined | PkgJson;
 export declare const isObject: (obj: unknown) => obj is Record<string, any>;
 export declare const isEmptyObject: (obj: object) => boolean;
 export declare function pick<T, U extends keyof T>(obj: T, keys: ReadonlyArray<U>): Pick<T, U>;
 export declare function omit<T extends object, U extends keyof T>(obj: T, keysObj: Record<U, boolean>): Omit<T, keyof U>;
-export declare function isPluginIncluded(config: LibConfig, pluginName: string): boolean;
+export declare function isPluginIncluded(pluginName: string, plugins?: RsbuildPlugins): boolean;
 export declare function checkMFPlugin(config: LibConfig): boolean;
 export { color };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rslib/core",
-  "version": "0.0.17",
+  "version": "0.1.0",
   "description": "The Rsbuild-based library development tool.",
   "homepage": "https://lib.rsbuild.dev",
   "bugs": {
@@ -32,19 +32,18 @@
     "compiled"
   ],
   "dependencies": {
-    "@rsbuild/core": "~1.1.0",
+    "@rsbuild/core": "~1.1.4",
     "tinyglobby": "^0.2.10",
-    "rsbuild-plugin-dts": "0.0.17"
+    "rsbuild-plugin-dts": "0.1.0"
   },
   "devDependencies": {
-    "@rspack/core": "1.0.8",
     "@types/fs-extra": "^11.0.4",
     "commander": "^12.1.0",
     "fs-extra": "^11.2.0",
     "memfs": "^4.14.0",
     "picocolors": "1.1.1",
     "prebundle": "1.2.5",
-    "rslib": "npm:@rslib/core@0.0.16",
+    "rslib": "npm:@rslib/core@0.0.18",
     "rslog": "^1.2.3",
     "tsconfck": "3.1.4",
     "typescript": "^5.6.3",

package/dist-types/build.d.ts

@@ -1,4 +0,0 @@
-import { type RsbuildInstance } from '@rsbuild/core';
-import type { BuildOptions } from './cli/commands';
-import type { RslibConfig } from './types/config';
-export declare function build(config: RslibConfig, options?: BuildOptions): Promise<RsbuildInstance>;