@rspack-canary/cli 1.4.12-canary-4f117639-20250801102630 → 1.4.12-canary-becf0a0e-20250808091433

package/dist/cli.d.ts

@@ -13,8 +13,12 @@ export declare class RspackCLI {
     getLogger(): RspackCLILogger;
     run(argv: string[]): Promise<void>;
     registerCommands(): Promise<void>;
-    buildConfig(item: RspackOptions | MultiRspackOptions, options: RspackBuildCLIOptions, command: Command): Promise<RspackOptions | MultiRspackOptions>;
-    loadConfig(options: RspackCLIOptions): Promise<RspackOptions | MultiRspackOptions>;
+    buildConfig(item: RspackOptions | MultiRspackOptions, pathMap: WeakMap<RspackOptions, string[]>, options: RspackBuildCLIOptions, command: Command): Promise<RspackOptions | MultiRspackOptions>;
+    loadConfig(options: RspackCLIOptions): Promise<{
+        config: RspackOptions | MultiRspackOptions;
+        pathMap: WeakMap<RspackOptions, string[]>;
+    }>;
+    private filterConfig;
     isMultipleCompiler(compiler: Compiler | MultiCompiler): compiler is MultiCompiler;
     isWatch(compiler: Compiler | MultiCompiler): boolean;
 }

package/dist/index.js

@@ -346,7 +346,7 @@ var __webpack_exports__ = {};
                     }
                 };
                 const { RspackDevServer } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "@rspack/dev-server"));
-                let config = await cli.loadConfig(rspackOptions);
+                let { config } = await cli.loadConfig(rspackOptions);
                 config = await getPreviewConfig(config, options);
                 if (!Array.isArray(config)) config = [
                     config
@@ -453,8 +453,8 @@ var __webpack_exports__ = {};
                     let finalMiddlewares = middlewares;
                     if (setupMiddlewares) finalMiddlewares = setupMiddlewares(finalMiddlewares, server);
                     return [
-                        lazyCompileMiddleware,
-                        ...finalMiddlewares
+                        ...finalMiddlewares,
+                        lazyCompileMiddleware
                     ];
                 };
                 result.hot = options.hot ?? result.hot ?? true;
@@ -562,17 +562,35 @@ var __webpack_exports__ = {};
     const checkIsMultiRspackOptions = (config)=>Array.isArray(config);
     async function loadExtendedConfig(config, configPath, cwd, options) {
         if (checkIsMultiRspackOptions(config)) {
-            const extendedConfigs = await Promise.all(config.map((item)=>loadExtendedConfig(item, configPath, cwd, options)));
+            const resultPathMap = new WeakMap();
+            const extendedConfigs = await Promise.all(config.map(async (item)=>{
+                const { config, pathMap } = await loadExtendedConfig(item, configPath, cwd, options);
+                resultPathMap.set(config, pathMap.get(config));
+                return config;
+            }));
             extendedConfigs.parallelism = config.parallelism;
-            return extendedConfigs;
+            return {
+                config: extendedConfigs,
+                pathMap: resultPathMap
+            };
         }
-        if (!("extends" in config) || !config.extends) return config;
+        const pathMap = new WeakMap();
+        pathMap.set(config, [
+            configPath
+        ]);
+        if (!("extends" in config) || !config.extends) return {
+            config,
+            pathMap
+        };
         const extendsList = Array.isArray(config.extends) ? config.extends : [
             config.extends
         ];
         const { extends: _, ...configWithoutExtends } = config;
         const baseDir = external_node_path_default().dirname(configPath);
         let resultConfig = configWithoutExtends;
+        pathMap.set(resultConfig, [
+            configPath
+        ]);
         for (const extendPath of extendsList){
             let resolvedPath;
             if (extendPath.startsWith(".") || extendPath.startsWith("/") || extendPath.includes(":\\")) {
@@ -594,34 +612,41 @@ var __webpack_exports__ = {};
             }
             if (!external_node_fs_default().existsSync(resolvedPath)) throw new Error(`Extended configuration file "${resolvedPath}" not found.`);
             if (isTsFile(resolvedPath) && "register" === options.configLoader) await registerLoader(resolvedPath);
-            let extendedConfig = await crossImport(resolvedPath, cwd);
-            if ("function" == typeof extendedConfig) {
+            let loadedConfig = await crossImport(resolvedPath, cwd);
+            if ("function" == typeof loadedConfig) {
                 var _options_argv;
-                extendedConfig = extendedConfig(null == (_options_argv = options.argv) ? void 0 : _options_argv.env, options.argv);
-                if ("function" == typeof extendedConfig.then) extendedConfig = await extendedConfig;
+                loadedConfig = loadedConfig(null == (_options_argv = options.argv) ? void 0 : _options_argv.env, options.argv);
+                if ("function" == typeof loadedConfig.then) loadedConfig = await loadedConfig;
             }
-            extendedConfig = await loadExtendedConfig(extendedConfig, resolvedPath, cwd, options);
+            const { config: extendedConfig, pathMap: extendedPathMap } = await loadExtendedConfig(loadedConfig, resolvedPath, cwd, options);
+            const configPaths = [
+                ...pathMap.get(resultConfig) || [],
+                ...extendedPathMap.get(extendedConfig) || []
+            ];
             resultConfig = core_.util.cleverMerge(extendedConfig, resultConfig);
+            pathMap.set(resultConfig, configPaths);
         }
-        return resultConfig;
+        return {
+            config: resultConfig,
+            pathMap
+        };
     }
     async function loadRspackConfig(options, cwd = process.cwd()) {
-        let configPath;
-        let loadedConfig;
+        let configPath = "";
         if (options.config) {
             configPath = external_node_path_default().resolve(cwd, options.config);
             if (!external_node_fs_default().existsSync(configPath)) throw new Error(`config file "${configPath}" not found.`);
-            if (isTsFile(configPath) && "register" === options.configLoader) await registerLoader(configPath);
-            loadedConfig = await crossImport(configPath, cwd);
         } else {
             const defaultConfig = utils_findConfig(external_node_path_default().resolve(cwd, loadConfig_DEFAULT_CONFIG_NAME));
-            if (!defaultConfig) return {};
+            if (!defaultConfig) return null;
             configPath = defaultConfig;
-            if (isTsFile(defaultConfig) && "register" === options.configLoader) await registerLoader(defaultConfig);
-            loadedConfig = await crossImport(defaultConfig, cwd);
         }
-        if ("function" != typeof loadedConfig && configPath) loadedConfig = await loadExtendedConfig(loadedConfig, configPath, cwd, options);
-        return loadedConfig;
+        if (isTsFile(configPath) && "register" === options.configLoader) await registerLoader(configPath);
+        const loadedConfig = await crossImport(configPath, cwd);
+        return {
+            loadedConfig,
+            configPath
+        };
     }
     function _define_property(obj, key, value) {
         if (key in obj) Object.defineProperty(obj, key, {
@@ -636,8 +661,8 @@ var __webpack_exports__ = {};
     class RspackCLI {
         async createCompiler(options, rspackCommand, callback) {
             process.env.RSPACK_CONFIG_VALIDATE ??= "loose";
-            let config = await this.loadConfig(options);
-            config = await this.buildConfig(config, options, rspackCommand);
+            let { config, pathMap } = await this.loadConfig(options);
+            config = await this.buildConfig(config, pathMap, options, rspackCommand);
             const isWatch = Array.isArray(config) ? config.some((i)=>i.watch) : config.watch;
             let compiler;
             try {
@@ -691,10 +716,11 @@ var __webpack_exports__ = {};
             ];
             for (const command of builtinCommands)command.apply(this);
         }
-        async buildConfig(item, options, command) {
+        async buildConfig(item, pathMap, options, command) {
             const isBuild = "build" === command;
             const isServe = "serve" === command;
             const internalBuildConfig = async (item)=>{
+                var _item_experiments;
                 if (options.entry) item.entry = {
                     main: options.entry.map((x)=>external_node_path_default().resolve(process.cwd(), x))[0]
                 };
@@ -725,6 +751,14 @@ var __webpack_exports__ = {};
                     const installed = (item.plugins ||= []).find((item)=>item instanceof core_.ProgressPlugin);
                     if (!installed) (item.plugins ??= []).push(new core_.ProgressPlugin());
                 }
+                const cacheOptions = null == (_item_experiments = item.experiments) ? void 0 : _item_experiments.cache;
+                if ("object" == typeof cacheOptions && "persistent" === cacheOptions.type) {
+                    const configPaths = pathMap.get(item);
+                    if (configPaths) cacheOptions.buildDependencies = [
+                        ...configPaths,
+                        ...cacheOptions.buildDependencies || []
+                    ];
+                }
                 if (void 0 === item.stats) item.stats = {
                     preset: "errors-warnings",
                     timings: true
@@ -744,22 +778,30 @@ var __webpack_exports__ = {};
             return internalBuildConfig(item);
         }
         async loadConfig(options) {
-            let loadedConfig = await loadRspackConfig(options);
+            const config = await loadRspackConfig(options);
+            if (!config) return {
+                config: this.filterConfig(options, {}),
+                pathMap: new WeakMap()
+            };
+            let { loadedConfig, configPath } = config;
             if ("function" == typeof loadedConfig) {
                 var _options_argv;
                 let functionResult = loadedConfig(null == (_options_argv = options.argv) ? void 0 : _options_argv.env, options.argv);
                 if ("function" == typeof functionResult.then) functionResult = await functionResult;
                 loadedConfig = functionResult;
-                if ("extends" in loadedConfig && loadedConfig.extends) {
-                    const tempConfigPath = external_node_path_default().resolve(process.cwd(), "rspack.config.js");
-                    loadedConfig = await loadExtendedConfig(loadedConfig, tempConfigPath, process.cwd(), options);
-                }
             }
+            const { config: extendedConfig, pathMap } = await loadExtendedConfig(loadedConfig, configPath, process.cwd(), options);
+            return {
+                config: this.filterConfig(options, extendedConfig),
+                pathMap
+            };
+        }
+        filterConfig(options, config) {
             if (options.configName) {
                 const notFoundConfigNames = [];
-                loadedConfig = options.configName.map((configName)=>{
+                config = options.configName.map((configName)=>{
                     let found;
-                    found = Array.isArray(loadedConfig) ? loadedConfig.find((options)=>options.name === configName) : loadedConfig.name === configName ? loadedConfig : void 0;
+                    found = Array.isArray(config) ? config.find((options)=>options.name === configName) : config.name === configName ? config : void 0;
                     if (!found) notFoundConfigNames.push(configName);
                     return found;
                 });
@@ -768,7 +810,7 @@ var __webpack_exports__ = {};
                     process.exit(2);
                 }
             }
-            return loadedConfig;
+            return config;
         }
         isMultipleCompiler(compiler) {
             return Boolean(compiler.compilers);

package/dist/index.mjs

@@ -311,7 +311,7 @@ class PreviewCommand {
                 }
             };
             const { RspackDevServer } = await import("@rspack/dev-server");
-            let config = await cli.loadConfig(rspackOptions);
+            let { config } = await cli.loadConfig(rspackOptions);
             config = await getPreviewConfig(config, options);
             if (!Array.isArray(config)) config = [
                 config
@@ -418,8 +418,8 @@ class ServeCommand {
                 let finalMiddlewares = middlewares;
                 if (setupMiddlewares) finalMiddlewares = setupMiddlewares(finalMiddlewares, server);
                 return [
-                    lazyCompileMiddleware,
-                    ...finalMiddlewares
+                    ...finalMiddlewares,
+                    lazyCompileMiddleware
                 ];
             };
             result.hot = options.hot ?? result.hot ?? true;
@@ -526,17 +526,35 @@ const registerLoader = async (configPath)=>{
 const checkIsMultiRspackOptions = (config)=>Array.isArray(config);
 async function loadExtendedConfig(config, configPath, cwd, options) {
     if (checkIsMultiRspackOptions(config)) {
-        const extendedConfigs = await Promise.all(config.map((item)=>loadExtendedConfig(item, configPath, cwd, options)));
+        const resultPathMap = new WeakMap();
+        const extendedConfigs = await Promise.all(config.map(async (item)=>{
+            const { config, pathMap } = await loadExtendedConfig(item, configPath, cwd, options);
+            resultPathMap.set(config, pathMap.get(config));
+            return config;
+        }));
         extendedConfigs.parallelism = config.parallelism;
-        return extendedConfigs;
+        return {
+            config: extendedConfigs,
+            pathMap: resultPathMap
+        };
     }
-    if (!("extends" in config) || !config.extends) return config;
+    const pathMap = new WeakMap();
+    pathMap.set(config, [
+        configPath
+    ]);
+    if (!("extends" in config) || !config.extends) return {
+        config,
+        pathMap
+    };
     const extendsList = Array.isArray(config.extends) ? config.extends : [
         config.extends
     ];
     const { extends: _, ...configWithoutExtends } = config;
     const baseDir = external_node_path_["default"].dirname(configPath);
     let resultConfig = configWithoutExtends;
+    pathMap.set(resultConfig, [
+        configPath
+    ]);
     for (const extendPath of extendsList){
         let resolvedPath;
         if (extendPath.startsWith(".") || extendPath.startsWith("/") || extendPath.includes(":\\")) {
@@ -558,34 +576,41 @@ async function loadExtendedConfig(config, configPath, cwd, options) {
         }
         if (!external_node_fs_["default"].existsSync(resolvedPath)) throw new Error(`Extended configuration file "${resolvedPath}" not found.`);
         if (isTsFile(resolvedPath) && "register" === options.configLoader) await registerLoader(resolvedPath);
-        let extendedConfig = await crossImport(resolvedPath, cwd);
-        if ("function" == typeof extendedConfig) {
+        let loadedConfig = await crossImport(resolvedPath, cwd);
+        if ("function" == typeof loadedConfig) {
             var _options_argv;
-            extendedConfig = extendedConfig(null == (_options_argv = options.argv) ? void 0 : _options_argv.env, options.argv);
-            if ("function" == typeof extendedConfig.then) extendedConfig = await extendedConfig;
+            loadedConfig = loadedConfig(null == (_options_argv = options.argv) ? void 0 : _options_argv.env, options.argv);
+            if ("function" == typeof loadedConfig.then) loadedConfig = await loadedConfig;
         }
-        extendedConfig = await loadExtendedConfig(extendedConfig, resolvedPath, cwd, options);
+        const { config: extendedConfig, pathMap: extendedPathMap } = await loadExtendedConfig(loadedConfig, resolvedPath, cwd, options);
+        const configPaths = [
+            ...pathMap.get(resultConfig) || [],
+            ...extendedPathMap.get(extendedConfig) || []
+        ];
         resultConfig = core_.util.cleverMerge(extendedConfig, resultConfig);
+        pathMap.set(resultConfig, configPaths);
     }
-    return resultConfig;
+    return {
+        config: resultConfig,
+        pathMap
+    };
 }
 async function loadRspackConfig(options, cwd = process.cwd()) {
-    let configPath;
-    let loadedConfig;
+    let configPath = "";
     if (options.config) {
         configPath = external_node_path_["default"].resolve(cwd, options.config);
         if (!external_node_fs_["default"].existsSync(configPath)) throw new Error(`config file "${configPath}" not found.`);
-        if (isTsFile(configPath) && "register" === options.configLoader) await registerLoader(configPath);
-        loadedConfig = await crossImport(configPath, cwd);
     } else {
         const defaultConfig = utils_findConfig(external_node_path_["default"].resolve(cwd, loadConfig_DEFAULT_CONFIG_NAME));
-        if (!defaultConfig) return {};
+        if (!defaultConfig) return null;
         configPath = defaultConfig;
-        if (isTsFile(defaultConfig) && "register" === options.configLoader) await registerLoader(defaultConfig);
-        loadedConfig = await crossImport(defaultConfig, cwd);
     }
-    if ("function" != typeof loadedConfig && configPath) loadedConfig = await loadExtendedConfig(loadedConfig, configPath, cwd, options);
-    return loadedConfig;
+    if (isTsFile(configPath) && "register" === options.configLoader) await registerLoader(configPath);
+    const loadedConfig = await crossImport(configPath, cwd);
+    return {
+        loadedConfig,
+        configPath
+    };
 }
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
@@ -600,8 +625,8 @@ function _define_property(obj, key, value) {
 class RspackCLI {
     async createCompiler(options, rspackCommand, callback) {
         process.env.RSPACK_CONFIG_VALIDATE ??= "loose";
-        let config = await this.loadConfig(options);
-        config = await this.buildConfig(config, options, rspackCommand);
+        let { config, pathMap } = await this.loadConfig(options);
+        config = await this.buildConfig(config, pathMap, options, rspackCommand);
         const isWatch = Array.isArray(config) ? config.some((i)=>i.watch) : config.watch;
         let compiler;
         try {
@@ -655,10 +680,11 @@ class RspackCLI {
         ];
         for (const command of builtinCommands)command.apply(this);
     }
-    async buildConfig(item, options, command) {
+    async buildConfig(item, pathMap, options, command) {
         const isBuild = "build" === command;
         const isServe = "serve" === command;
         const internalBuildConfig = async (item)=>{
+            var _item_experiments;
             if (options.entry) item.entry = {
                 main: options.entry.map((x)=>external_node_path_["default"].resolve(process.cwd(), x))[0]
             };
@@ -689,6 +715,14 @@ class RspackCLI {
                 const installed = (item.plugins ||= []).find((item)=>item instanceof core_.ProgressPlugin);
                 if (!installed) (item.plugins ??= []).push(new core_.ProgressPlugin());
             }
+            const cacheOptions = null == (_item_experiments = item.experiments) ? void 0 : _item_experiments.cache;
+            if ("object" == typeof cacheOptions && "persistent" === cacheOptions.type) {
+                const configPaths = pathMap.get(item);
+                if (configPaths) cacheOptions.buildDependencies = [
+                    ...configPaths,
+                    ...cacheOptions.buildDependencies || []
+                ];
+            }
             if (void 0 === item.stats) item.stats = {
                 preset: "errors-warnings",
                 timings: true
@@ -708,22 +742,30 @@ class RspackCLI {
         return internalBuildConfig(item);
     }
     async loadConfig(options) {
-        let loadedConfig = await loadRspackConfig(options);
+        const config = await loadRspackConfig(options);
+        if (!config) return {
+            config: this.filterConfig(options, {}),
+            pathMap: new WeakMap()
+        };
+        let { loadedConfig, configPath } = config;
         if ("function" == typeof loadedConfig) {
             var _options_argv;
             let functionResult = loadedConfig(null == (_options_argv = options.argv) ? void 0 : _options_argv.env, options.argv);
             if ("function" == typeof functionResult.then) functionResult = await functionResult;
             loadedConfig = functionResult;
-            if ("extends" in loadedConfig && loadedConfig.extends) {
-                const tempConfigPath = external_node_path_["default"].resolve(process.cwd(), "rspack.config.js");
-                loadedConfig = await loadExtendedConfig(loadedConfig, tempConfigPath, process.cwd(), options);
-            }
         }
+        const { config: extendedConfig, pathMap } = await loadExtendedConfig(loadedConfig, configPath, process.cwd(), options);
+        return {
+            config: this.filterConfig(options, extendedConfig),
+            pathMap
+        };
+    }
+    filterConfig(options, config) {
         if (options.configName) {
             const notFoundConfigNames = [];
-            loadedConfig = options.configName.map((configName)=>{
+            config = options.configName.map((configName)=>{
                 let found;
-                found = Array.isArray(loadedConfig) ? loadedConfig.find((options)=>options.name === configName) : loadedConfig.name === configName ? loadedConfig : void 0;
+                found = Array.isArray(config) ? config.find((options)=>options.name === configName) : config.name === configName ? config : void 0;
                 if (!found) notFoundConfigNames.push(configName);
                 return found;
             });
@@ -732,7 +774,7 @@ class RspackCLI {
                 process.exit(2);
             }
         }
-        return loadedConfig;
+        return config;
     }
     isMultipleCompiler(compiler) {
         return Boolean(compiler.compilers);

package/dist/utils/loadConfig.d.ts

@@ -9,5 +9,19 @@ export type LoadedRspackConfig = undefined | RspackOptions | MultiRspackOptions
  * @param options CLI options
  * @returns The merged configuration
  */
-export declare function loadExtendedConfig(config: RspackOptions | MultiRspackOptions, configPath: string, cwd: string, options: RspackCLIOptions): Promise<RspackOptions | MultiRspackOptions>;
-export declare function loadRspackConfig(options: RspackCLIOptions, cwd?: string): Promise<LoadedRspackConfig>;
+export declare function loadExtendedConfig(config: RspackOptions, configPath: string, cwd: string, options: RspackCLIOptions): Promise<{
+    config: RspackOptions;
+    pathMap: WeakMap<RspackOptions, string[]>;
+}>;
+export declare function loadExtendedConfig(config: MultiRspackOptions, configPath: string, cwd: string, options: RspackCLIOptions): Promise<{
+    config: MultiRspackOptions;
+    pathMap: WeakMap<RspackOptions, string[]>;
+}>;
+export declare function loadExtendedConfig(config: RspackOptions | MultiRspackOptions, configPath: string, cwd: string, options: RspackCLIOptions): Promise<{
+    config: RspackOptions | MultiRspackOptions;
+    pathMap: WeakMap<RspackOptions, string[]>;
+}>;
+export declare function loadRspackConfig(options: RspackCLIOptions, cwd?: string): Promise<{
+    loadedConfig: LoadedRspackConfig;
+    configPath: string;
+} | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack-canary/cli",
-  "version": "1.4.12-canary-4f117639-20250801102630",
+  "version": "1.4.12-canary-becf0a0e-20250808091433",
   "description": "CLI for rspack",
   "homepage": "https://rspack.rs",
   "bugs": "https://github.com/web-infra-dev/rspack/issues",
@@ -48,7 +48,7 @@
     "execa": "^5.1.1",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3",
-    "@rspack/core": "npm:@rspack-canary/core@1.4.12-canary-4f117639-20250801102630"
+    "@rspack/core": "npm:@rspack-canary/core@1.4.12-canary-becf0a0e-20250808091433"
   },
   "peerDependencies": {
     "@rspack/core": "^1.0.0-alpha || ^1.x"