@rspack/cli 2.0.2 → 2.0.4

package/bin/rspack.js

@@ -12,9 +12,6 @@ if (enableCompileCache) {
   }
 }
 
-// make it easier to identify the process via activity monitor or other tools
-process.title = 'rspack-node';
-
 import { RspackCLI } from '../dist/index.js';
 
 async function runCLI() {

package/dist/index.d.ts

@@ -256,7 +256,7 @@ export declare class RspackCLI {
      */
     wrapAction<T extends (...args: any[]) => Promise<void>>(fn: T): T;
     buildCompilerConfig(options: CommonOptionsForBuildAndServe, rspackCommand: Command_2): Promise<RspackOptions | MultiRspackOptions>;
-    createCompiler(config: RspackOptions | MultiRspackOptions, callback?: (e: Error | null, res?: Stats | MultiStats) => void): Promise<MultiCompiler | Compiler | null>;
+    createCompiler(config: RspackOptions | MultiRspackOptions, callback?: (e: Error | null, res?: Stats | MultiStats) => void): Compiler | MultiCompiler | null;
     private createColors;
     getLogger(): RspackCLILogger;
     run(argv: string[]): Promise<void>;
@@ -289,7 +289,7 @@ export declare interface RspackCLILogger {
 }
 
 export declare interface RspackCommand {
-    apply(cli: RspackCLI): Promise<void>;
+    apply(cli: RspackCLI): void | Promise<void>;
 }
 
 declare type RspackConfigAsyncFn = (env: Record<string, any>, argv: Record<string, any>) => Promise<RspackOptions | MultiRspackOptions>;

package/dist/index.js

@@ -2,9 +2,8 @@ import node_path from "node:path";
 import node_util from "node:util";
 import { rspack } from "@rspack/core";
 import node_fs from "node:fs";
-import { Readable } from "node:stream";
 import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 function toArr(any) {
     return null == any ? [] : Array.isArray(any) ? any : [
         any
@@ -593,7 +592,7 @@ const normalizeCommonOptions = (options, action)=>{
     }
     if ('devtool' in options) options.devtool = normalizeDevtoolOption(options.devtool);
 };
-const commonOptionsForBuildAndServe = (command)=>command.option('-d, --devtool <value>', 'specify a developer tool for debugging. Defaults to `cheap-module-source-map` in development and `source-map` in production.').option('--entry <entry>', 'entry file', {
+const commonOptionsForBuildAndServe = (command)=>command.option('-d, --devtool <value>', 'set source map style for debugging. Use `false` to disable source maps.').option('--entry <entry>', 'entry file', {
         type: [
             String
         ],
@@ -633,8 +632,9 @@ async function runBuild(cli, options) {
     const logger = cli.getLogger();
     let createJsonStringifyStream;
     if (options.json) {
+        const stream = await import("node:stream");
         const jsonExt = await import("./json-ext.js");
-        createJsonStringifyStream = (value)=>Readable.from(jsonExt.stringifyChunked(value));
+        createJsonStringifyStream = (value)=>stream.Readable.from(jsonExt.stringifyChunked(value));
     }
     const errorHandler = (error, stats)=>{
         if (error) {
@@ -675,7 +675,7 @@ async function runBuild(cli, options) {
     });
 }
 class BuildCommand {
-    async apply(cli) {
+    apply(cli) {
         const command = cli.program.command('', 'run the Rspack build').alias('build').alias('bundle').alias('b');
         commonOptionsForBuildAndServe(commonOptions(command)).option('--json [path]', 'emit stats json');
         command.action(cli.wrapAction(async (options)=>{
@@ -684,7 +684,7 @@ class BuildCommand {
     }
 }
 class PreviewCommand {
-    async apply(cli) {
+    apply(cli) {
         const command = cli.program.command('preview [dir]', 'run the Rspack server for build output').alias('p');
         commonOptions(command).option('--public-path <path>', 'static resource server path').option('--port <port>', 'preview server port').option('--host <host>', 'preview server host').option('--open', 'open browser').option('--server <config>', 'Configuration items for the server.');
         command.action(cli.wrapAction(async (dir, options)=>{
@@ -724,7 +724,7 @@ class PreviewCommand {
 }
 async function getPreviewConfig(item, options, dir) {
     const DEFAULT_ROOT = 'dist';
-    const internalPreviewConfig = async (item)=>{
+    const internalPreviewConfig = (item)=>{
         const devServer = false === item.devServer ? void 0 : item.devServer;
         item.devServer = {
             static: {
@@ -750,7 +750,7 @@ function normalizeHotOption(value) {
     return value;
 }
 class ServeCommand {
-    async apply(cli) {
+    apply(cli) {
         const command = cli.program.command('serve', 'run the rspack dev server.').alias('server').alias('s').alias('dev');
         commonOptionsForBuildAndServe(commonOptions(command)).option('--hot [mode]', 'enables hot module replacement').option('--port <port>', 'allows to specify a port to use').option('--host <host>', 'allows to specify a hostname to use').option('--open [value]', 'open browser on server start; pass --no-open to disable, or --open <url> to open a specific URL');
         command.action(cli.wrapAction(async (cliOptions)=>{
@@ -848,6 +848,100 @@ class ServeCommand {
         }));
     }
 }
+function mergeWith(objects, customizer) {
+    const [first, ...rest] = objects;
+    let ret = first;
+    rest.forEach((a)=>{
+        ret = mergeTo(ret, a, customizer);
+    });
+    return ret;
+}
+function mergeTo(a, b, customizer) {
+    const ret = {};
+    Object.keys(a).concat(Object.keys(b)).forEach((k)=>{
+        const v = customizer(a[k], b[k], k);
+        ret[k] = void 0 === v ? a[k] : v;
+    });
+    return ret;
+}
+const merge_with = mergeWith;
+function isRegex(o) {
+    return o instanceof RegExp;
+}
+function isPlainObject(value) {
+    if ('[object Object]' !== Object.prototype.toString.call(value)) return false;
+    const proto = Object.getPrototypeOf(value);
+    if (null === proto) return true;
+    let baseProto = proto;
+    while(null !== Object.getPrototypeOf(baseProto))baseProto = Object.getPrototypeOf(baseProto);
+    return proto === baseProto;
+}
+function isUndefined(value) {
+    return void 0 === value;
+}
+function isPromiseLike(value) {
+    return null !== value && ('object' == typeof value || 'function' == typeof value) && 'function' == typeof value.then;
+}
+const isArray = Array.isArray;
+function joinArrays({ customizeArray, customizeObject, key } = {}) {
+    return function _joinArrays(a, b, k) {
+        const newKey = key ? `${key}.${k}` : k;
+        if ('function' == typeof a && 'function' == typeof b) return (...args)=>_joinArrays(a(...args), b(...args), k);
+        if (isArray(a) && isArray(b)) {
+            const customResult = customizeArray && customizeArray(a, b, newKey);
+            return customResult || [
+                ...a,
+                ...b
+            ];
+        }
+        if (isRegex(b)) return b;
+        if (isPlainObject(a) && isPlainObject(b)) {
+            const customResult = customizeObject && customizeObject(a, b, newKey);
+            return customResult || merge_with([
+                a,
+                b
+            ], joinArrays({
+                customizeArray,
+                customizeObject,
+                key: newKey
+            }));
+        }
+        if (isPlainObject(b)) return merge_with([
+            {},
+            b
+        ], joinArrays({
+            customizeArray,
+            customizeObject,
+            key: newKey
+        }));
+        if (isArray(b)) return [
+            ...b
+        ];
+        return b;
+    };
+}
+function merge(firstConfiguration, ...configurations) {
+    return mergeWithCustomize({})(firstConfiguration, ...configurations);
+}
+function mergeWithCustomize(options) {
+    return function(firstConfiguration, ...configurations) {
+        if (isUndefined(firstConfiguration) || configurations.some(isUndefined)) throw new TypeError('Merging undefined is not supported');
+        if (isPromiseLike(firstConfiguration)) throw new TypeError('Promises are not supported');
+        if (!firstConfiguration) return {};
+        if (0 === configurations.length) {
+            if (Array.isArray(firstConfiguration)) {
+                if (0 === firstConfiguration.length) return {};
+                if (firstConfiguration.some(isUndefined)) throw new TypeError('Merging undefined is not supported');
+                if (isPromiseLike(firstConfiguration[0])) throw new TypeError('Promises are not supported');
+                return merge_with(firstConfiguration, joinArrays(options));
+            }
+            return firstConfiguration;
+        }
+        return merge_with([
+            firstConfiguration
+        ].concat(configurations), joinArrays(options));
+    };
+}
 const DEFAULT_EXTENSIONS = [
     '.ts',
     '.js',
@@ -926,11 +1020,13 @@ const resolveRspackConfigExport = async (configExport, options)=>{
     return loadedConfig;
 };
 const checkIsMultiRspackOptions = (config)=>Array.isArray(config);
-async function loadExtendedConfig(config, configPath, cwd, options) {
+async function loadExtendedConfig(config, configPath, cwd, options, visitedPaths) {
+    const currentVisitedPaths = visitedPaths ?? new Set();
     if (checkIsMultiRspackOptions(config)) {
         const resultPathMap = new WeakMap();
         const extendedConfigs = await Promise.all(config.map(async (item)=>{
-            const { config, pathMap } = await loadExtendedConfig(item, configPath, cwd, options);
+            const itemVisitedPaths = new Set(currentVisitedPaths);
+            const { config, pathMap } = await loadExtendedConfig(item, configPath, cwd, options, itemVisitedPaths);
             resultPathMap.set(config, pathMap.get(config));
             return config;
         }));
@@ -940,6 +1036,8 @@ async function loadExtendedConfig(config, configPath, cwd, options) {
             pathMap: resultPathMap
         };
     }
+    if (currentVisitedPaths.has(configPath)) throw new Error(`Recursive configuration detected. Config file "${configPath}" extends itself.`);
+    currentVisitedPaths.add(configPath);
     const pathMap = new WeakMap();
     pathMap.set(config, [
         configPath
@@ -959,7 +1057,12 @@ async function loadExtendedConfig(config, configPath, cwd, options) {
     ]);
     for (const extendPath of extendsList){
         let resolvedPath;
-        if (extendPath.startsWith('.') || extendPath.startsWith('/') || extendPath.includes(':\\')) {
+        if (extendPath.startsWith('file://')) try {
+            resolvedPath = fileURLToPath(extendPath);
+        } catch  {
+            throw new Error(`Invalid file URL '${extendPath}' in extends configuration.`);
+        }
+        else if (extendPath.startsWith('.') || extendPath.startsWith('/') || extendPath.includes(':\\')) {
             resolvedPath = node_path.resolve(baseDir, extendPath);
             if (!node_path.extname(resolvedPath)) {
                 const foundConfig = utils_findConfig(resolvedPath);
@@ -979,12 +1082,12 @@ async function loadExtendedConfig(config, configPath, cwd, options) {
         if (!node_fs.existsSync(resolvedPath)) throw new Error(`Extended configuration file "${resolvedPath}" not found.`);
         const loadedConfig = await loadConfigByPath(resolvedPath, options);
         const resolvedConfig = await resolveRspackConfigExport(loadedConfig, options);
-        const { config: extendedConfig, pathMap: extendedPathMap } = await loadExtendedConfig(resolvedConfig, resolvedPath, cwd, options);
+        const { config: extendedConfig, pathMap: extendedPathMap } = await loadExtendedConfig(resolvedConfig, resolvedPath, cwd, options, currentVisitedPaths);
         const configPaths = [
             ...pathMap.get(resultConfig) || [],
             ...extendedPathMap.get(extendedConfig) || []
         ];
-        resultConfig = rspack.util.cleverMerge(extendedConfig, resultConfig);
+        resultConfig = merge(extendedConfig, resultConfig);
         pathMap.set(resultConfig, configPaths);
     }
     return {
@@ -1040,7 +1143,7 @@ class RspackCLI {
         this.colors = this.createColors();
         this.program = program;
         program.help();
-        program.version("2.0.2");
+        program.version("2.0.4");
     }
     wrapAction(fn) {
         return (...args)=>{
@@ -1049,11 +1152,11 @@ class RspackCLI {
         };
     }
     async buildCompilerConfig(options, rspackCommand) {
-        let { config, pathMap } = await this.loadConfig(options);
-        config = await this.buildConfig(config, pathMap, options, rspackCommand);
+        const { config: rawConfig, pathMap } = await this.loadConfig(options);
+        const config = await this.buildConfig(rawConfig, pathMap, options, rspackCommand);
         return config;
     }
-    async createCompiler(config, callback) {
+    createCompiler(config, callback) {
         const isWatch = Array.isArray(config) ? config.some((i)=>i.watch) : config.watch;
         let compiler;
         try {

package/dist/profile.js

@@ -1,21 +1,25 @@
 import node_fs from "node:fs";
 import node_path from "node:path";
 import { rspack } from "@rspack/core";
-const DEFAULT_RUST_TRACE_LAYER = 'perfetto';
+const DEFAULT_RUST_TRACE_LAYER = 'logger';
+const DEFAULT_RUST_TRACE_LOGGER_OUTPUT = 'rspack.log';
+const DEFAULT_RUST_TRACE_PERFETTO_OUTPUT = 'rspack.pftrace';
+function isTerminalTraceOutput(output) {
+    return 'stdout' === output || 'stderr' === output;
+}
 async function applyProfile(filterValue, traceLayer = DEFAULT_RUST_TRACE_LAYER, traceOutput) {
     const { asyncExitHook } = await import("./exit-hook.js");
     if ('logger' !== traceLayer && 'perfetto' !== traceLayer) throw new Error(`unsupported trace layer: ${traceLayer}`);
+    if (traceOutput && 'perfetto' === traceLayer && isTerminalTraceOutput(traceOutput)) throw new Error('RSPACK_TRACE_OUTPUT=stdout|stderr is only supported for the logger trace layer. The perfetto trace layer requires a file path.');
     const timestamp = Date.now();
     const defaultOutputDir = node_path.resolve(`.rspack-profile-${timestamp}-${process.pid}`);
     if (traceOutput) {
-        if ('stdout' !== traceOutput && 'stderr' !== traceOutput) traceOutput = node_path.resolve(defaultOutputDir, traceOutput);
+        if (!isTerminalTraceOutput(traceOutput)) traceOutput = node_path.resolve(defaultOutputDir, traceOutput);
     } else {
-        const defaultRustTracePerfettoOutput = node_path.resolve(defaultOutputDir, 'rspack.pftrace');
-        const defaultRustTraceLoggerOutput = 'stdout';
-        const defaultTraceOutput = 'perfetto' === traceLayer ? defaultRustTracePerfettoOutput : defaultRustTraceLoggerOutput;
-        traceOutput = defaultTraceOutput;
+        const defaultRustTraceOutput = 'perfetto' === traceLayer ? DEFAULT_RUST_TRACE_PERFETTO_OUTPUT : DEFAULT_RUST_TRACE_LOGGER_OUTPUT;
+        traceOutput = node_path.resolve(defaultOutputDir, defaultRustTraceOutput);
     }
-    await ensureFileDir(traceOutput);
+    if (!isTerminalTraceOutput(traceOutput)) await ensureFileDir(traceOutput);
     await rspack.experiments.globalTrace.register(filterValue, traceLayer, traceOutput);
     asyncExitHook(rspack.experiments.globalTrace.cleanup, {
         wait: 500

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/cli",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "CLI for rspack",
   "homepage": "https://rspack.rs",
   "bugs": "https://github.com/web-infra-dev/rspack/issues",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@discoveryjs/json-ext": "^1.1.0",
     "@microsoft/api-extractor": "^7.58.7",
-    "@rslib/core": "0.21.3",
+    "@rslib/core": "^0.21.5",
     "@rspack/dev-server": "^2.0.1",
     "cac": "^7.0.0",
     "concat-stream": "^2.0.0",
@@ -39,9 +39,10 @@
     "exit-hook": "^5.1.0",
     "jiti": "^2.6.1",
     "prebundle": "^1.6.4",
+    "rspack-merge": "0.1.1",
     "typescript": "^6.0.3",
-    "@rspack/core": "2.0.2",
-    "@rspack/test-tools": "2.0.2"
+    "@rspack/core": "2.0.4",
+    "@rspack/test-tools": "2.0.4"
   },
   "peerDependencies": {
     "@rspack/core": "^2.0.0-0",