@rslib/core 0.0.2 → 0.0.4

package/bin/rslib.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { logger, prepareCli, runCli } from '../dist/main.js';
+import { logger, prepareCli, runCli } from '../dist/index.js';
 
 async function main() {
   prepareCli();

package/dist/{main.js → index.js}

@@ -460,7 +460,7 @@ async function calcLongestCommonPath(absPaths) {
     return lca;
 }
 const readPackageJson = (rootPath)=>{
-    const pkgJsonPath = external_node_path_namespaceObject["default"].resolve(rootPath, './package.json');
+    const pkgJsonPath = external_node_path_namespaceObject["default"].join(rootPath, './package.json');
     if (!external_node_fs_namespaceObject["default"].existsSync(pkgJsonPath)) {
         dist_logger.warn(`package.json does not exist in the ${rootPath} directory`);
         return;
@@ -473,6 +473,25 @@ const readPackageJson = (rootPath)=>{
     }
 };
 const isObject = (obj)=>Object.prototype.toString.call(obj) === '[object Object]';
+function omitDeep(obj, keys) {
+    if (typeof obj === 'string' || typeof obj !== 'object' || obj === null) return obj;
+    if (Array.isArray(obj)) {
+        return obj.map((item)=>omitDeep(item, keys));
+    }
+    const clone = {};
+    for(const property in obj){
+        if (keys.includes(property)) {
+            continue;
+        }
+        const value = obj[property];
+        if (value && typeof value === 'object') {
+            clone[property] = omitDeep(value, keys);
+        } else {
+            clone[property] = value;
+        }
+    }
+    return clone;
+}
 
 
 ;// CONCATENATED MODULE: ./src/utils/logger.ts
@@ -525,7 +544,7 @@ function prepareCli() {
     if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) {
         console.log();
     }
-    dist_logger.greet(`  ${`Rslib v${"0.0.2"}`}\n`);
+    dist_logger.greet(`  ${`Rslib v${"0.0.4"}`}\n`);
 }
 
 ;// CONCATENATED MODULE: external "../compiled/commander/index.js"
@@ -755,11 +774,10 @@ const resolveConfigPath = (root, customConfig)=>{
     if (configFilePath) {
         return configFilePath;
     }
-    return undefined;
+    throw new Error(`${DEFAULT_CONFIG_NAME} not found in ${root}`);
 };
-async function loadConfig(customConfig, envMode) {
-    const root = process.cwd();
-    const configFilePath = resolveConfigPath(root, customConfig);
+async function loadConfig({ cwd = process.cwd(), path, envMode }) {
+    const configFilePath = resolveConfigPath(cwd, path);
     const { content } = await (0,core_namespaceObject.loadConfig)({
         cwd: (0,external_node_path_namespaceObject.dirname)(configFilePath),
         path: configFilePath,
@@ -767,6 +785,87 @@ async function loadConfig(customConfig, envMode) {
     });
     return content;
 }
+const composeExternalsWarnConfig = (format, ...externalsArray)=>{
+    if (format !== 'esm') {
+        return {};
+    }
+    const externals = [];
+    for (const e of externalsArray.filter(Boolean)){
+        if (Array.isArray(e)) {
+            externals.push(...e);
+        } else {
+            // @ts-ignore
+            externals.push(e);
+        }
+    }
+    // Match logic is derived from https://github.com/webpack/webpack/blob/94aba382eccf3de1004d235045d4462918dfdbb7/lib/ExternalModuleFactoryPlugin.js#L166-L293.
+    const matchUserExternals = (externals, request, callback)=>{
+        if (typeof externals === 'string') {
+            if (externals === request) {
+                callback(true);
+                return;
+            }
+        } else if (Array.isArray(externals)) {
+            let i = 0;
+            const next = ()=>{
+                let asyncFlag;
+                const handleExternalsAndCallback = (matched)=>{
+                    if (!matched) {
+                        if (asyncFlag) {
+                            asyncFlag = false;
+                            return;
+                        }
+                        return next();
+                    }
+                    callback(matched);
+                };
+                do {
+                    asyncFlag = true;
+                    if (i >= externals.length) {
+                        return callback();
+                    }
+                    matchUserExternals(externals[i++], request, handleExternalsAndCallback);
+                }while (!asyncFlag);
+                asyncFlag = false;
+            };
+            next();
+            return;
+        } else if (externals instanceof RegExp) {
+            if (externals.test(request)) {
+                callback(true);
+                return;
+            }
+        } else if (typeof externals === 'function') {} else // TODO: Support function
+        if (typeof externals === 'object') {
+            if (Object.prototype.hasOwnProperty.call(externals, request)) {
+                callback(true);
+                return;
+            }
+        }
+        callback();
+    };
+    return {
+        output: {
+            externals: [
+                ({ request, dependencyType, contextInfo }, callback)=>{
+                    let externalized = false;
+                    const _callback = (matched)=>{
+                        if (matched) {
+                            externalized = true;
+                        }
+                    };
+                    if (contextInfo.issuer && dependencyType === 'commonjs') {
+                        matchUserExternals(externals, request, _callback);
+                        if (externalized) {
+                            dist_logger.warn(composeModuleImportWarn(request));
+                        }
+                    }
+                    callback();
+                }
+            ]
+        }
+    };
+};
 const composeAutoExternalConfig = (options)=>{
     const { autoExternal, pkgJson, userExternals } = options;
     if (!autoExternal) {
@@ -807,7 +906,7 @@ const composeAutoExternalConfig = (options)=>{
         }
     } : {};
 };
-async function createInternalRsbuildConfig() {
+async function createConstantRsbuildConfig() {
     return (0,core_namespaceObject.defineConfig)({
         mode: 'production',
         dev: {
@@ -825,13 +924,54 @@ async function createInternalRsbuildConfig() {
                             force: false
                         }
                     }
+                },
+                // TypeScript-specific behavior: if the extension is ".js" or ".jsx", try replacing it with ".ts" or ".tsx"
+                // see https://github.com/web-infra-dev/rslib/issues/41
+                resolve: {
+                    extensionAlias: {
+                        '.js': [
+                            '.ts',
+                            '.tsx',
+                            '.js',
+                            '.jsx'
+                        ],
+                        '.jsx': [
+                            '.tsx',
+                            '.jsx'
+                        ],
+                        '.mjs': [
+                            '.mts',
+                            '.mjs'
+                        ],
+                        '.cjs': [
+                            '.cts',
+                            '.cjs'
+                        ]
+                    }
                 }
             }
         },
         output: {
             filenameHash: false,
-            // TODO: easy to development at the moment
-            minify: false,
+            minify: {
+                js: true,
+                css: false,
+                jsOptions: {
+                    minimizerOptions: {
+                        mangle: false,
+                        minify: false,
+                        compress: {
+                            defaults: false,
+                            unused: true,
+                            dead_code: true,
+                            toplevel: true
+                        },
+                        format: {
+                            comments: 'all'
+                        }
+                    }
+                }
+            },
             distPath: {
                 js: './'
             }
@@ -844,7 +984,6 @@ const composeFormatConfig = (format)=>{
             return {
                 tools: {
                     rspack: {
-                        externalsType: 'module-import',
                         output: {
                             module: true,
                             chunkFormat: 'module',
@@ -872,7 +1011,6 @@ const composeFormatConfig = (format)=>{
             return {
                 tools: {
                     rspack: {
-                        externalsType: 'commonjs',
                         output: {
                             iife: false,
                             chunkFormat: 'commonjs',
@@ -887,7 +1025,6 @@ const composeFormatConfig = (format)=>{
             return {
                 tools: {
                     rspack: {
-                        externalsType: 'umd',
                         output: {
                             library: {
                                 type: 'umd'
@@ -900,9 +1037,39 @@ const composeFormatConfig = (format)=>{
             throw new Error(`Unsupported format: ${format}`);
     }
 };
-const composeAutoExtensionConfig = (format, autoExtension, pkgJson)=>{
+const composeModuleImportWarn = (request)=>{
+    return `The externalized commonjs request ${index_js_namespaceObject["default"].green(`"${request}"`)} will use ${index_js_namespaceObject["default"].blue('"module"')} external type in ESM format. If you want to specify other external type, considering set the request and type with ${index_js_namespaceObject["default"].blue('"output.externals"')}.`;
+};
+const composeExternalsConfig = (format, externals)=>{
+    // TODO: Define the internal externals config in Rsbuild's externals instead
+    // Rspack's externals as they will not be merged from different fields. All externals
+    // should to be unified and merged together in the future.
+    const externalsTypeMap = {
+        esm: 'module-import',
+        cjs: 'commonjs',
+        umd: 'umd'
+    };
+    switch(format){
+        case 'esm':
+        case 'cjs':
+        case 'umd':
+            return {
+                output: externals ? {
+                    externals
+                } : {},
+                tools: {
+                    rspack: {
+                        externalsType: externalsTypeMap[format]
+                    }
+                }
+            };
+        default:
+            throw new Error(`Unsupported format: ${format}`);
+    }
+};
+const composeAutoExtensionConfig = (config, autoExtension, pkgJson)=>{
     const { jsExtension, dtsExtension } = getDefaultExtension({
-        format,
+        format: config.format,
         pkgJson,
         autoExtension
     });
@@ -910,7 +1077,8 @@ const composeAutoExtensionConfig = (format, autoExtension, pkgJson)=>{
         config: {
             output: {
                 filename: {
-                    js: `[name]${jsExtension}`
+                    js: `[name]${jsExtension}`,
+                    ...config.output?.filename
                 }
             }
         },
@@ -985,8 +1153,8 @@ const composeEntryConfig = async (entries, bundle, root)=>{
     for (const key of Object.keys(entries)){
         const entry = entries[key];
         // Entries in bundleless mode could be:
-        // 1. A string of glob pattern: { entry: { main: 'src/*.ts' } }
-        // 2. An array of glob patterns: { entry: { main: ['src/*.ts', 'src/*.tsx'] } }
+        // 1. A string of glob pattern: { entry: { index: 'src/*.ts' } }
+        // 2. An array of glob patterns: { entry: { index: ['src/*.ts', 'src/*.tsx'] } }
         // Not supported for now: entry description object
         const entryFiles = Array.isArray(entry) ? entry : typeof entry === 'string' ? [
             entry
@@ -1028,8 +1196,16 @@ const composeBundleConfig = (jsExtension, bundle = true)=>{
                     // Prevent from externalizing entry modules here.
                     if (data.contextInfo.issuer) {
                         // Node.js ECMAScript module loader does no extension searching.
-                        // So we add a file extension here when data.request is a relative path
-                        return callback(null, data.request[0] === '.' ? `${data.request}${jsExtension}` : data.request);
+                        // Add a file extension according to autoExtension config
+                        // when data.request is a relative path and do not have an extension.
+                        // If data.request already have an extension, we replace it with new extension
+                        // 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;
+                        if (request[0] === '.') {
+                            request = (0,external_node_path_namespaceObject.extname)(request) ? request.replace(/\.[^.]+$/, jsExtension) : `${request}${jsExtension}`;
+                        }
+                        return callback(null, request);
                     }
                     callback();
                 }
@@ -1100,48 +1276,65 @@ const composeTargetConfig = (target = 'web')=>{
             throw new Error(`Unsupported platform: ${target}`);
     }
 };
-async function composeLibRsbuildConfig(libConfig, rsbuildConfig, configPath) {
-    const config = (0,core_namespaceObject.mergeRsbuildConfig)(rsbuildConfig, libConfig);
+async function composeLibRsbuildConfig(config, configPath) {
     const rootPath = (0,external_node_path_namespaceObject.dirname)(configPath);
     const pkgJson = readPackageJson(rootPath);
     const { format, autoExtension = true, autoExternal = true } = config;
     const formatConfig = composeFormatConfig(format);
-    const { config: autoExtensionConfig, jsExtension, dtsExtension } = composeAutoExtensionConfig(format, autoExtension, pkgJson);
+    const externalsConfig = composeExternalsConfig(format, config.output?.externals);
+    const { config: autoExtensionConfig, jsExtension, dtsExtension } = composeAutoExtensionConfig(config, autoExtension, pkgJson);
     const bundleConfig = composeBundleConfig(jsExtension, config.bundle);
     const targetConfig = composeTargetConfig(config.output?.target);
     const syntaxConfig = composeSyntaxConfig(config.output?.syntax, config.output?.target);
     const autoExternalConfig = composeAutoExternalConfig({
         autoExternal,
         pkgJson,
-        userExternals: rsbuildConfig.output?.externals
+        userExternals: config.output?.externals
     });
     const entryConfig = await composeEntryConfig(config.source?.entry, config.bundle, (0,external_node_path_namespaceObject.dirname)(configPath));
     const dtsConfig = await composeDtsConfig(config, dtsExtension);
-    return (0,core_namespaceObject.mergeRsbuildConfig)(formatConfig, autoExtensionConfig, autoExternalConfig, syntaxConfig, bundleConfig, targetConfig, entryConfig, dtsConfig);
+    const externalsWarnConfig = composeExternalsWarnConfig(format, autoExternalConfig?.output?.externals, externalsConfig?.output?.externals);
+    return (0,core_namespaceObject.mergeRsbuildConfig)(formatConfig, // externalsWarnConfig should before other externals config
+    externalsWarnConfig, externalsConfig, autoExternalConfig, autoExtensionConfig, syntaxConfig, bundleConfig, targetConfig, entryConfig, dtsConfig);
 }
 async function composeCreateRsbuildConfig(rslibConfig, path) {
-    const internalRsbuildConfig = await createInternalRsbuildConfig();
+    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 { format, ...overrideRsbuildConfig } = libConfig;
-        const baseRsbuildConfig = (0,core_namespaceObject.mergeRsbuildConfig)(sharedRsbuildConfig, overrideRsbuildConfig);
+        const userConfig = (0,core_namespaceObject.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(libConfig, baseRsbuildConfig, configPath);
+        const libRsbuildConfig = await composeLibRsbuildConfig(userConfig, configPath);
         // 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.
-        baseRsbuildConfig.source ??= {};
-        baseRsbuildConfig.source.entry = {};
+        userConfig.source ??= {};
+        userConfig.source.entry = {};
+        // Already manually sort and merge the externals configuration.
+        userConfig.output ??= {};
+        delete userConfig.output.externals;
         return {
-            format: format,
-            config: (0,core_namespaceObject.mergeRsbuildConfig)(baseRsbuildConfig, libRsbuildConfig, // Merge order matters, keep `internalRsbuildConfig` at the last position
-            // to ensure that the internal config is not overridden by user's config.
-            internalRsbuildConfig)
+            format: libConfig.format,
+            // The merge order represents the priority of the configuration
+            // The priorities from high to low are as follows:
+            // 1 - userConfig: users can configure any Rsbuild and Rspack config
+            // 2 - libRsbuildConfig: the configuration that we compose from Rslib unique config and userConfig from 1
+            // 3 - constantRsbuildConfig: the built-in best practice Rsbuild configuration we provide in Rslib
+            // We should state in the document that the built-in configuration should not be changed optionally
+            // 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,core_namespaceObject.mergeRsbuildConfig)(constantRsbuildConfig, libRsbuildConfig, omitDeep(userConfig, [
+                'bundle',
+                'format',
+                'autoExtension',
+                'autoExternal',
+                'syntax',
+                'dts'
+            ]))
         };
     });
     const composedRsbuildConfig = await Promise.all(libConfigPromises);
@@ -1190,7 +1383,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() {
-    commander_index_js_namespaceObject.program.name('rslib').usage('<command> [options]').version("0.0.2");
+    commander_index_js_namespaceObject.program.name('rslib').usage('<command> [options]').version("0.0.4");
     const buildCommand = commander_index_js_namespaceObject.program.command('build');
     const inspectCommand = commander_index_js_namespaceObject.program.command('inspect');
     [
@@ -1199,7 +1392,10 @@ function runCli() {
     ].forEach(applyCommonOptions);
     buildCommand.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(options.config, options.envMode);
+            const rslibConfig = await loadConfig({
+                path: options.config,
+                envMode: options.envMode
+            });
             await build(rslibConfig, options);
         } catch (err) {
             dist_logger.error('Failed to build.');
@@ -1210,7 +1406,10 @@ function runCli() {
     inspectCommand.description('inspect the Rslib / Rsbuild / Rspack configs').option('--env <env>', 'specify env mode', 'development').option('--output <output>', 'specify inspect content output path', './').option('--verbose', 'show full function definitions in output').action(async (options)=>{
         try {
             // TODO: inspect should output Rslib's config
-            const rslibConfig = await loadConfig(options.config, options.envMode);
+            const rslibConfig = await loadConfig({
+                path: options.config,
+                envMode: options.envMode
+            });
             const rsbuildInstance = await initRsbuild(rslibConfig);
             await rsbuildInstance.inspectConfig({
                 mode: options.mode,
@@ -1233,6 +1432,6 @@ function runCli() {
 
 
 
-const src_version = "0.0.2";
+const src_version = "0.0.4";
 
 export { build, defineConfig, loadConfig, dist_logger as logger, prepareCli, runCli, src_version as version };

package/dist-types/config.d.ts

@@ -8,13 +8,18 @@ export declare function defineConfig(config: RslibConfig): RslibConfig;
 export declare function defineConfig(config: RslibConfigSyncFn): RslibConfigSyncFn;
 export declare function defineConfig(config: RslibConfigAsyncFn): RslibConfigAsyncFn;
 export declare function defineConfig(config: RslibConfigExport): RslibConfigExport;
-export declare function loadConfig(customConfig?: string, envMode?: string): Promise<RslibConfig>;
+export declare function loadConfig({ cwd, path, envMode, }: {
+    cwd?: string;
+    path?: string;
+    envMode?: string;
+}): Promise<RslibConfig>;
 export declare const composeAutoExternalConfig: (options: {
     autoExternal: AutoExternal;
     pkgJson?: PkgJson;
     userExternals?: NonNullable<RsbuildConfig["output"]>["externals"];
 }) => RsbuildConfig;
-export declare function createInternalRsbuildConfig(): Promise<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;

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

@@ -1,4 +1,4 @@
-import type { Format, PkgJson } from 'src/types';
+import type { Format, PkgJson } from '../types';
 export declare const getDefaultExtension: (options: {
     format: Format;
     pkgJson?: PkgJson;

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

@@ -8,4 +8,8 @@ export declare const nodeBuiltInModules: Array<string | RegExp>;
 export declare function calcLongestCommonPath(absPaths: string[]): Promise<string | null>;
 export declare const readPackageJson: (rootPath: string) => undefined | PkgJson;
 export declare const isObject: (obj: unknown) => obj is Record<string, any>;
+type OmitDeep<T, K extends string[]> = T extends (infer U)[] ? OmitDeep<U, K>[] : T extends Record<any, any> ? {
+    [P in keyof T as P extends K[number] ? never : P]: OmitDeep<T[P], K>;
+} : T;
+export declare function omitDeep<T extends object, K extends string[]>(obj: T, keys: K): OmitDeep<T, K>;
 export { color };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rslib/core",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "The Rspack-based library build tool.",
   "homepage": "https://rslib.dev",
   "bugs": {
@@ -16,11 +16,11 @@
   "exports": {
     ".": {
       "types": "./dist-types/index.d.ts",
-      "default": "./dist/main.js"
+      "default": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
-  "main": "./dist/main.js",
+  "main": "./dist/index.js",
   "types": "./dist-types/index.d.ts",
   "bin": {
     "rslib": "./bin/rslib.js"
@@ -32,8 +32,8 @@
     "compiled"
   ],
   "dependencies": {
-    "@rsbuild/core": "1.0.1-beta.11",
-    "rsbuild-plugin-dts": "0.0.2"
+    "@rsbuild/core": "1.0.1-rc.0",
+    "rsbuild-plugin-dts": "0.0.4"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
@@ -42,8 +42,8 @@
     "fs-extra": "^11.2.0",
     "memfs": "^4.11.1",
     "picocolors": "1.0.1",
-    "prebundle": "1.1.0",
-    "rslib": "npm:@rslib/core@0.0.0",
+    "prebundle": "1.2.2",
+    "rslib": "npm:@rslib/core@0.0.3",
     "rslog": "^1.2.2",
     "typescript": "^5.5.4",
     "@rslib/tsconfig": "0.0.1"