@rslib/core 0.0.9 → 0.0.10

package/dist/index.js

@@ -6,6 +6,7 @@ import * as __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js__ from "../c
 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__compiled_fast_glob_index_js__ from "../compiled/fast-glob/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE_node_module__ from "node:module";
 import * as __WEBPACK_EXTERNAL_MODULE_module__ from "module";
 /**
  * Node.js built-in modules.
@@ -133,7 +134,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.9\n`);
+    __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.greet(`  Rslib v0.0.10\n`);
 }
 const DEFAULT_CONFIG_NAME = 'rslib.config';
 const DEFAULT_CONFIG_EXTENSIONS = [
@@ -170,7 +171,124 @@ const ENTRY_EXTENSIONS = [
     ...CSS_EXTENSIONS
 ];
 const JS_EXTENSIONS_PATTERN = new RegExp(`\\.(${JS_EXTENSIONS.join('|')})$`);
+const CSS_EXTENSIONS_PATTERN = new RegExp(`\\.(${CSS_EXTENSIONS.join('|')})$`);
 const ENTRY_EXTENSIONS_PATTERN = new RegExp(`\\.(${ENTRY_EXTENSIONS.join('|')})$`);
+const pluginName = 'REMOVE_CSS_EXTRACT_ASSET_PLUGIN';
+class RemoveCssExtractAssetPlugin {
+    name = pluginName;
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    apply(compiler) {
+        const include = this.options.include;
+        compiler.hooks.thisCompilation.tap(pluginName, (compilation)=>{
+            compilation.hooks.chunkAsset.tap(pluginName, (_chunk, filename)=>{
+                const asset = compilation.getAsset(filename);
+                if (!asset) return;
+                const needRemove = Boolean(asset.name.match(include));
+                if (needRemove) compilation.deleteAsset(filename);
+            });
+        });
+    }
+}
+const cssConfig_require = (0, __WEBPACK_EXTERNAL_MODULE_node_module__.createRequire)(import.meta.url);
+const RSLIB_CSS_ENTRY_FLAG = '__rslib_css__';
+function isCssFile(filepath) {
+    return CSS_EXTENSIONS_PATTERN.test(filepath);
+}
+const CSS_MODULE_REG = /\.module\.\w+$/i;
+/**
+ * This function is modified based on
+ * https://github.com/web-infra-dev/rspack/blob/7b80a45a1c58de7bc506dbb107fad6fda37d2a1f/packages/rspack/src/loader-runner/index.ts#L903
+ */ const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\u200b.|[^?#\u200b])*)(\?(?:\u200b.|[^#\u200b])*)?(#.*)?$/;
+function parsePathQueryFragment(str) {
+    const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+    return {
+        path: match?.[1]?.replace(/\u200b(.)/g, '$1') || '',
+        query: match?.[2] ? match[2].replace(/\u200b(.)/g, '$1') : '',
+        fragment: match?.[3] || ''
+    };
+}
+function isCssModulesFile(filepath, auto) {
+    const filename = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].basename(filepath);
+    if (true === auto) return CSS_MODULE_REG.test(filename);
+    if (auto instanceof RegExp) return auto.test(filepath);
+    if ('function' == typeof auto) {
+        const { path, query, fragment } = parsePathQueryFragment(filepath);
+        // this is a mock for loader
+        return auto(path, query, fragment);
+    }
+    return false;
+}
+function isCssGlobalFile(filepath, auto) {
+    const isCss = isCssFile(filepath);
+    if (!isCss) return false;
+    const isCssModules = isCssModulesFile(filepath, auto);
+    return !isCssModules;
+}
+function cssExternalHandler(request, callback, jsExtension, auto, isStyleRedirect) {
+    const isCssModulesRequest = isCssModulesFile(request, auto);
+    // cssExtract would execute the file handled by css-loader, so we cannot external the "helper import" from css-loader
+    // do not external @rsbuild/core/compiled/css-loader/noSourceMaps.js, sourceMaps.js, api.mjs etc.
+    if (/compiled\/css-loader\//.test(request)) return callback();
+    // 1. css modules: import './CounterButton.module.scss' -> import './CounterButton.module.mjs'
+    // 2. css global: import './CounterButton.scss' -> import './CounterButton.css'
+    if ('.' === request[0] && isCssFile(request)) {
+        // preserve import './CounterButton.module.scss'
+        if (!isStyleRedirect) return callback(null, request);
+        if (isCssModulesRequest) return callback(null, request.replace(/\.[^.]+$/, jsExtension));
+        return callback(null, request.replace(/\.[^.]+$/, '.css'));
+    }
+    return false;
+}
+const cssConfig_pluginName = 'rsbuild:lib-css';
+const pluginLibCss = (rootDir)=>({
+        name: cssConfig_pluginName,
+        setup (api) {
+            api.modifyBundlerChain((config, { CHAIN_ID })=>{
+                let isUsingCssExtract = false;
+                for (const ruleId of [
+                    CHAIN_ID.RULE.CSS,
+                    CHAIN_ID.RULE.SASS,
+                    CHAIN_ID.RULE.LESS,
+                    CHAIN_ID.RULE.STYLUS
+                ]){
+                    const rule = config.module.rule(ruleId);
+                    if (rule.uses.has(CHAIN_ID.USE.MINI_CSS_EXTRACT)) {
+                        isUsingCssExtract = true;
+                        rule.use(CHAIN_ID.USE.MINI_CSS_EXTRACT).loader(cssConfig_require.resolve('./libCssExtractLoader.js')).options({
+                            rootDir
+                        });
+                    }
+                }
+                if (isUsingCssExtract) {
+                    const cssExtract = CHAIN_ID.PLUGIN.MINI_CSS_EXTRACT;
+                    config.plugins.delete(cssExtract);
+                    config.plugin(RemoveCssExtractAssetPlugin.name).use(RemoveCssExtractAssetPlugin, [
+                        {
+                            include: new RegExp(`^${RSLIB_CSS_ENTRY_FLAG}`)
+                        }
+                    ]);
+                }
+            });
+        }
+    });
+const composeCssConfig = (rootDir, bundle = true)=>{
+    if (bundle || null === rootDir) return {};
+    return {
+        plugins: [
+            pluginLibCss(rootDir)
+        ],
+        tools: {
+            cssLoader: {
+                // Otherwise, external variables will be executed by css-extract and cause an error.
+                // e.g: `@import url('./a.css');`
+                import: false
+            }
+        }
+    };
+};
 const importMetaUrlShim = `var __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
   return typeof document === 'undefined'
     ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
@@ -561,10 +679,31 @@ const IS_POSIX = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].posix.sep ===
         // filename must end with part of pattern that comes after last wildcard
         let lastWildcardIndex = pattern.length;
         let hasWildcard = false;
-        for(let i = pattern.length - 1; i > -1; i--)if ('*' === pattern[i] || '?' === pattern[i]) {
-            lastWildcardIndex = i;
+        let hasExtension = false;
+        let hasSlash = false;
+        let lastSlashIndex = -1;
+        for(let i = pattern.length - 1; i > -1; i--){
+            const c = pattern[i];
+            if (!hasWildcard) {
+                if ('*' === c || '?' === c) {
+                    lastWildcardIndex = i;
+                    hasWildcard = true;
+                }
+            }
+            if (!hasSlash) {
+                if ('.' === c) hasExtension = true;
+                else if ('/' === c) {
+                    lastSlashIndex = i;
+                    hasSlash = true;
+                }
+            }
+            if (hasWildcard && hasSlash) break;
+        }
+        if (!hasExtension && (!hasWildcard || lastWildcardIndex < lastSlashIndex)) {
+            // add implicit glob
+            pattern += `${pattern.endsWith('/') ? '' : '/'}${GLOB_ALL_PATTERN}`;
+            lastWildcardIndex = pattern.length - 1;
             hasWildcard = true;
-            break;
         }
         // if pattern does not end with wildcard, filename must end with pattern after last wildcard
         if (lastWildcardIndex < pattern.length - 1 && !filename.endsWith(pattern.slice(lastWildcardIndex + 1))) return false;
@@ -581,8 +720,10 @@ const IS_POSIX = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].posix.sep ===
             break;
         }
         if (firstWildcardIndex > 1 && !filename.startsWith(resolvedPattern.slice(0, firstWildcardIndex - 1))) return false;
-        // if no wildcard in pattern, filename must be equal to resolved pattern
-        if (!hasWildcard) return filename === resolvedPattern;
+        if (!hasWildcard) //  no wildcard in pattern, filename must be equal to resolved pattern
+        return filename === resolvedPattern;
+        if (firstWildcardIndex + GLOB_ALL_PATTERN.length === resolvedPattern.length - (pattern.length - 1 - lastWildcardIndex) && resolvedPattern.slice(firstWildcardIndex, firstWildcardIndex + GLOB_ALL_PATTERN.length) === GLOB_ALL_PATTERN) // singular glob-all pattern and we already validated prefix and suffix matches
+        return true;
         // complex pattern, use regex to check it
         if (PATTERN_REGEX_CACHE.has(resolvedPattern)) return PATTERN_REGEX_CACHE.get(resolvedPattern).test(filename);
         const regex = pattern2regex(resolvedPattern, allowJs);
@@ -1231,20 +1372,22 @@ const composeAutoExternalConfig = (options)=>{
         __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn('autoExternal configuration will not be applied due to read package.json failed');
         return {};
     }
+    // User externals configuration has higher priority than autoExternal
+    // eg: autoExternal: ['react'], user: output: { externals: { react: 'react-1' } }
+    // Only handle the case where the externals type is object, string / string[] does not need to be processed, other types are too complex.
+    const userExternalKeys = userExternals && isObject(userExternals) ? Object.keys(userExternals) : [];
     const externalOptions = {
         dependencies: true,
+        optionalDependencies: true,
         peerDependencies: true,
         devDependencies: false,
         ...true === autoExternal ? {} : autoExternal
     };
-    // User externals configuration has higher priority than autoExternal
-    // eg: autoExternal: ['react'], user: output: { externals: { react: 'react-1' } }
-    // Only handle the case where the externals type is object, string / string[] does not need to be processed, other types are too complex.
-    const userExternalKeys = userExternals && isObject(userExternals) ? Object.keys(userExternals) : [];
     const externals = [
         'dependencies',
         'peerDependencies',
-        'devDependencies'
+        'devDependencies',
+        'optionalDependencies'
     ].reduce((prev, type)=>{
         if (externalOptions[type]) return pkgJson[type] ? prev.concat(Object.keys(pkgJson[type])) : prev;
         return prev;
@@ -1562,12 +1705,18 @@ const composeSyntaxConfig = (syntax, target)=>{
         }
     };
 };
-const composeEntryConfig = async (entries, bundle, root)=>{
-    if (!entries) return {};
+const composeEntryConfig = async (entries, bundle, root, cssModulesAuto)=>{
+    if (!entries) return {
+        entryConfig: {},
+        lcp: null
+    };
     if (false !== bundle) return {
-        source: {
-            entry: entries
-        }
+        entryConfig: {
+            source: {
+                entry: entries
+            }
+        },
+        lcp: null
     };
     // In bundleless mode, resolve glob patterns and convert them to entry object.
     const resolvedEntries = {};
@@ -1592,21 +1741,35 @@ const composeEntryConfig = async (entries, bundle, root)=>{
         const lcp = await calcLongestCommonPath(resolvedEntryFiles);
         // Using the longest common path of all non-declaration input files by default.
         const outBase = null === lcp ? root : lcp;
-        for (const file of resolvedEntryFiles){
+        function getEntryName(file) {
             const { dir, name } = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].parse(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].relative(outBase, file));
             // Entry filename contains nested path to preserve source directory structure.
             const entryFileName = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(dir, name);
-            resolvedEntries[entryFileName] = file;
+            // 1. we mark the global css files (which will generate empty js chunk in cssExtract), and deleteAsset in RemoveCssExtractAssetPlugin
+            // 2. avoid the same name e.g: `index.ts` and `index.css`
+            if (isCssGlobalFile(file, cssModulesAuto)) return `${RSLIB_CSS_ENTRY_FLAG}/${entryFileName}`;
+            return entryFileName;
+        }
+        for (const file of resolvedEntryFiles){
+            const entryName = getEntryName(file);
+            if (resolvedEntries[entryName]) __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger.warn(`duplicate entry: ${entryName}, this may lead to the incorrect output, please rename the file`);
+            resolvedEntries[entryName] = file;
         }
     }
-    return {
+    const lcp = await calcLongestCommonPath(Object.values(resolvedEntries));
+    const entryConfig = {
         source: {
             entry: resolvedEntries
         }
     };
+    return {
+        entryConfig,
+        lcp
+    };
 };
-const composeBundleConfig = (jsExtension, bundle = true)=>{
+const composeBundleConfig = (jsExtension, redirect, cssModulesAuto, bundle = true)=>{
     if (bundle) return {};
+    const isStyleRedirect = redirect.style ?? true;
     return {
         output: {
             externals: [
@@ -1621,8 +1784,11 @@ const composeBundleConfig = (jsExtension, bundle = true)=>{
                         // This may result in a change in semantics,
                         // user should use copy to keep origin file or use another separate entry to deal this
                         let request = data.request;
+                        const cssExternal = cssExternalHandler(request, callback, jsExtension, cssModulesAuto, isStyleRedirect);
+                        if (false !== cssExternal) return cssExternal;
                         if ('.' === request[0]) {
-                            if ((0, __WEBPACK_EXTERNAL_MODULE_node_path__.extname)(request)) {
+                            const ext = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.extname)(request);
+                            if (ext) {
                                 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);
@@ -1646,7 +1812,7 @@ const composeDtsConfig = async (libConfig, dtsExtension)=>{
                 bundle: dts?.bundle ?? bundle,
                 distPath: dts?.distPath ?? output?.distPath?.root ?? './dist',
                 abortOnError: dts?.abortOnError ?? true,
-                dtsExtension,
+                dtsExtension: dts?.autoExtension ? dtsExtension : '.d.ts',
                 autoExternal,
                 banner: banner?.dts,
                 footer: footer?.dts
@@ -1728,12 +1894,13 @@ async function composeLibRsbuildConfig(config, configPath) {
     const rootPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(configPath);
     const pkgJson = readPackageJson(rootPath);
     const { compilerOptions } = await loadTsconfig(rootPath, config.source?.tsconfigPath);
-    const { format, banner = {}, footer = {}, autoExtension = true, autoExternal = true, externalHelpers = false } = config;
+    const cssModulesAuto = config.output?.cssModules?.auto ?? true;
+    const { format, banner = {}, footer = {}, autoExtension = true, autoExternal = true, externalHelpers = false, redirect = {} } = config;
     const formatConfig = composeFormatConfig(format);
     const externalHelpersConfig = composeExternalHelpersConfig(externalHelpers, pkgJson);
     const externalsConfig = composeExternalsConfig(format, config.output?.externals);
     const { config: autoExtensionConfig, jsExtension, dtsExtension } = composeAutoExtensionConfig(config, autoExtension, pkgJson);
-    const bundleConfig = composeBundleConfig(jsExtension, config.bundle);
+    const bundleConfig = composeBundleConfig(jsExtension, redirect, cssModulesAuto, config.bundle);
     const targetConfig = composeTargetConfig(config.output?.target);
     const syntaxConfig = composeSyntaxConfig(config?.syntax, config.output?.target);
     const autoExternalConfig = composeAutoExternalConfig({
@@ -1741,13 +1908,14 @@ async function composeLibRsbuildConfig(config, configPath) {
         pkgJson,
         userExternals: config.output?.externals
     });
-    const entryConfig = await composeEntryConfig(config.source?.entry, config.bundle, (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(configPath));
+    const { entryConfig, lcp } = await composeEntryConfig(config.source?.entry, config.bundle, (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(configPath), cssModulesAuto);
+    const cssConfig = composeCssConfig(lcp, config.bundle);
     const dtsConfig = await composeDtsConfig(config, dtsExtension);
     const externalsWarnConfig = composeExternalsWarnConfig(format, autoExternalConfig?.output?.externals, externalsConfig?.output?.externals);
     const minifyConfig = composeMinifyConfig(config.output?.minify);
     const bannerFooterConfig = composeBannerFooterConfig(banner, footer);
     const decoratorsConfig = composeDecoratorsConfig(compilerOptions, config.source?.decorators?.version);
-    return (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.mergeRsbuildConfig)(formatConfig, externalHelpersConfig, externalsWarnConfig, externalsConfig, autoExternalConfig, autoExtensionConfig, syntaxConfig, bundleConfig, targetConfig, entryConfig, minifyConfig, dtsConfig, bannerFooterConfig, decoratorsConfig);
+    return (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.mergeRsbuildConfig)(formatConfig, externalHelpersConfig, externalsWarnConfig, externalsConfig, autoExternalConfig, autoExtensionConfig, syntaxConfig, bundleConfig, targetConfig, entryConfig, cssConfig, minifyConfig, dtsConfig, bannerFooterConfig, decoratorsConfig);
 }
 async function composeCreateRsbuildConfig(rslibConfig, path) {
     const constantRsbuildConfig = await createConstantRsbuildConfig();
@@ -1782,6 +1950,7 @@ async function composeCreateRsbuildConfig(rslibConfig, path) {
                 'format',
                 'autoExtension',
                 'autoExternal',
+                'redirect',
                 'syntax',
                 'externalHelpers',
                 'banner',
@@ -1827,7 +1996,7 @@ 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');
 };
 function runCli() {
-    __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.name('rslib').usage('<command> [options]').version("0.0.9");
+    __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.name('rslib').usage('<command> [options]').version("0.0.10");
     const buildCommand = __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.command('build');
     const inspectCommand = __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.command('inspect');
     [
@@ -1869,6 +2038,6 @@ function runCli() {
     });
     __WEBPACK_EXTERNAL_MODULE__compiled_commander_index_js__.program.parse();
 }
-const src_version = "0.0.9";
+const src_version = "0.0.10";
 var __webpack_exports__logger = __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js__.logger;
 export { build, defineConfig, loadConfig, prepareCli, runCli, src_version as version, __webpack_exports__logger as logger };

package/dist/libCssExtractLoader.js

@@ -0,0 +1,125 @@
+import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
+/**
+ * The following code is modified based on
+ * https://github.com/web-infra-dev/rspack/blob/0a89e433a9f8596a7c6c4326542f168b5982d2da/packages/rspack/src/builtin-plugin/css-extract/loader.ts
+ * 1. remove hmr/webpack runtime
+ * 2. add `this.emitFile` to emit css files
+ * 3. add `import './[name].css';`
+ */ const PLUGIN_NAME = 'LIB_CSS_EXTRACT_LOADER';
+function stringifyLocal(value) {
+    return 'function' == typeof value ? value.toString() : JSON.stringify(value);
+}
+const libCssExtractLoader_loader = function(content) {
+    if (this._compiler?.options?.experiments?.css && this._module && ('css' === this._module.type || 'css/auto' === this._module.type || 'css/global' === this._module.type || 'css/module' === this._module.type)) return content;
+};
+const pitch = function(request, _, _data) {
+    if (this._compiler?.options?.experiments?.css && this._module && ('css' === this._module.type || 'css/auto' === this._module.type || 'css/global' === this._module.type || 'css/module' === this._module.type)) {
+        const e = new Error("use type 'css' and `CssExtractRspackPlugin` together, please set `experiments.css` to `false` or set `{ type: \"javascript/auto\" }` for rules with `CssExtractRspackPlugin` in your rspack config (now `CssExtractRspackPlugin` does nothing).");
+        e.stack = void 0;
+        this.emitWarning(e);
+        return;
+    }
+    const options = this.getOptions();
+    const emit = void 0 === options.emit || options.emit;
+    const callback = this.async();
+    const filepath = this.resourcePath;
+    const rootDir = options.rootDir ?? this.rootContext;
+    const handleExports = (originalExports)=>{
+        let locals;
+        let namedExport;
+        const esModule = void 0 === options.esModule || options.esModule;
+        let dependencies = [];
+        try {
+            // eslint-disable-next-line no-underscore-dangle
+            const exports = originalExports.__esModule ? originalExports.default : originalExports;
+            namedExport = originalExports.__esModule && (!originalExports.default || !('locals' in originalExports.default));
+            if (namedExport) {
+                for (const key of Object.keys(originalExports))if ('default' !== key) {
+                    if (!locals) locals = {};
+                    locals[key] = originalExports[key];
+                }
+            } else locals = exports?.locals;
+            if (Array.isArray(exports) && emit) {
+                const identifierCountMap = new Map();
+                dependencies = exports.map(([id, content, media, sourceMap, supports, layer])=>{
+                    const identifier = id;
+                    const context = this.rootContext;
+                    const count = identifierCountMap.get(identifier) || 0;
+                    identifierCountMap.set(identifier, count + 1);
+                    return {
+                        identifier,
+                        context,
+                        content,
+                        media,
+                        supports,
+                        layer,
+                        identifierIndex: count,
+                        sourceMap: sourceMap ? JSON.stringify(sourceMap) : void 0,
+                        filepath
+                    };
+                }).filter((item)=>null !== item);
+            }
+        } catch (e) {
+            callback(e);
+            return;
+        }
+        const result = function() {
+            if (locals) {
+                if (namedExport) {
+                    const identifiers = Array.from(function*() {
+                        let identifierId = 0;
+                        for (const key of Object.keys(locals)){
+                            identifierId += 1;
+                            yield [
+                                `_${identifierId.toString(16)}`,
+                                key
+                            ];
+                        }
+                    }());
+                    const localsString = identifiers.map(([id, key])=>`\nvar ${id} = ${stringifyLocal(locals[key])};`).join('');
+                    const exportsString = `export { ${identifiers.map(([id, key])=>`${id} as ${JSON.stringify(key)}`).join(', ')} }`;
+                    const defaultExport = void 0 !== options.defaultExport && options.defaultExport;
+                    return defaultExport ? `${localsString}\n${exportsString}\nexport default { ${identifiers.map(([id, key])=>`${JSON.stringify(key)}: ${id}`).join(', ')} }\n` : `${localsString}\n${exportsString}\n`;
+                }
+                return `\n${esModule ? 'export default' : 'module.exports = '} ${JSON.stringify(locals)};`;
+            }
+            if (esModule) return '\nexport {};';
+            return '';
+        }();
+        let resultSource = `// extracted by ${PLUGIN_NAME}`;
+        let importCssFiles = '';
+        function getRelativePath(from, to) {
+            let relativePath = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].relative(from, to);
+            if (!relativePath.startsWith('./') && !relativePath.startsWith('../') && !__WEBPACK_EXTERNAL_MODULE_node_path__["default"].isAbsolute(relativePath)) relativePath = `./${relativePath}`;
+            return relativePath;
+        }
+        const m = new Map();
+        for (const { content, filepath } of dependencies){
+            let distFilepath = getRelativePath(rootDir, filepath);
+            const ext = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.extname)(distFilepath);
+            if ('css' !== ext) distFilepath = distFilepath.replace(ext, '.css');
+            distFilepath = distFilepath.replace(/\.module\.css/, '_module.css');
+            const cssFilename = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].basename(distFilepath);
+            if (content.trim()) {
+                m.get(distFilepath) ? m.set(distFilepath, `${m.get(distFilepath) + content}\n`) : m.set(distFilepath, `${content}\n`);
+                importCssFiles += '\n';
+                importCssFiles += `import "./${cssFilename}"`;
+            }
+        }
+        for (const [distFilepath, content] of m.entries())this.emitFile(distFilepath, content);
+        resultSource += importCssFiles;
+        resultSource += result;
+        callback(null, resultSource, void 0);
+    };
+    this.importModule(`${this.resourcePath}.webpack[javascript/auto]!=!!!${request}`, {
+        layer: options.layer
+    }, (error, exports)=>{
+        if (error) {
+            callback(error);
+            return;
+        }
+        handleExports(exports);
+    });
+};
+/* harmony default export */ const libCssExtractLoader = libCssExtractLoader_loader;
+export { libCssExtractLoader as default, pitch };

package/dist-types/constant.d.ts

@@ -5,4 +5,5 @@ export declare const JS_EXTENSIONS: string[];
 export declare const CSS_EXTENSIONS: string[];
 export declare const ENTRY_EXTENSIONS: string[];
 export declare const JS_EXTENSIONS_PATTERN: RegExp;
+export declare const CSS_EXTENSIONS_PATTERN: RegExp;
 export declare const ENTRY_EXTENSIONS_PATTERN: RegExp;

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

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

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

@@ -0,0 +1,17 @@
+import type { CSSLoaderOptions, RsbuildConfig } from '@rsbuild/core';
+export declare const RSLIB_CSS_ENTRY_FLAG = "__rslib_css__";
+export type CssLoaderOptionsAuto = CSSLoaderOptions['modules'] extends infer T ? T extends {
+    auto?: any;
+} ? T['auto'] : never : never;
+export declare function isCssFile(filepath: string): boolean;
+export declare function parsePathQueryFragment(str: string): {
+    path: string;
+    query: string;
+    fragment: string;
+};
+export declare function isCssModulesFile(filepath: string, auto: CssLoaderOptionsAuto): boolean;
+export declare function isCssGlobalFile(filepath: string, auto: CssLoaderOptionsAuto): boolean;
+type ExternalCallback = (arg0?: null, arg1?: string) => void;
+export declare function cssExternalHandler(request: string, callback: ExternalCallback, jsExtension: string, auto: CssLoaderOptionsAuto, isStyleRedirect: boolean): void | false;
+export declare const composeCssConfig: (rootDir: string | null, bundle?: boolean) => RsbuildConfig;
+export {};

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

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

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

@@ -1,15 +1,14 @@
 import type { RsbuildConfig } from '@rsbuild/core';
+import type { PluginDtsOptions } from 'rsbuild-plugin-dts';
 export type Format = 'esm' | 'cjs' | 'umd';
 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 RsbuildConfigOutputTarget = NonNullable<RsbuildConfig['output']>['target'];
 export type Syntax = EcmaScriptVersion | string[];
-export type Dts = {
-    bundle: boolean;
-    distPath?: string;
-    abortOnError?: boolean;
-} | false;
+export type Dts = (Pick<PluginDtsOptions, 'bundle' | 'distPath' | 'abortOnError'> & {
+    autoExtension?: boolean;
+}) | false;
 export type AutoExternal = boolean | {
     dependencies?: boolean;
     devDependencies?: boolean;
@@ -20,11 +19,15 @@ export type BannerAndFooter = {
     css?: string;
     dts?: string;
 };
+export type Redirect = {
+    style?: boolean;
+};
 export interface LibConfig extends RsbuildConfig {
     bundle?: boolean;
     format?: Format;
     autoExtension?: boolean;
     autoExternal?: AutoExternal;
+    redirect?: Redirect;
     /** Support esX and browserslist query */
     syntax?: Syntax;
     externalHelpers?: boolean;

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

@@ -1,6 +1,7 @@
 export type PkgJson = {
+    type?: 'module' | 'commonjs';
     dependencies?: Record<string, string>;
     peerDependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;
-    [key: string]: unknown;
+    optionalDependencies?: Record<string, string>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rslib/core",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "The Rspack-based library build tool.",
   "homepage": "https://lib.rsbuild.dev",
   "bugs": {
@@ -32,10 +32,11 @@
     "compiled"
   ],
   "dependencies": {
-    "@rsbuild/core": "1.0.10",
-    "rsbuild-plugin-dts": "0.0.9"
+    "@rsbuild/core": "1.0.12",
+    "rsbuild-plugin-dts": "0.0.10"
   },
   "devDependencies": {
+    "@rspack/core": "1.0.8",
     "@types/fs-extra": "^11.0.4",
     "commander": "^12.1.0",
     "fast-glob": "^3.3.2",
@@ -43,10 +44,10 @@
     "memfs": "^4.13.0",
     "picocolors": "1.1.0",
     "prebundle": "1.2.2",
-    "rslib": "npm:@rslib/core@0.0.8",
+    "rslib": "npm:@rslib/core@0.0.9",
     "rslog": "^1.2.3",
-    "tsconfck": "3.1.3",
-    "typescript": "^5.6.2",
+    "tsconfck": "3.1.4",
+    "typescript": "^5.6.3",
     "@rslib/tsconfig": "0.0.1"
   },
   "peerDependencies": {