@rspack/cli 2.1.2 → 2.1.4

package/dist/freshImport.js

@@ -0,0 +1,111 @@
+import { Module } from "node:module";
+import { fileURLToPath } from "node:url";
+import { MessageChannel } from "node:worker_threads";
+const instanceId = Math.random().toString(36).slice(2);
+const relativeImportRE = /^\.{1,2}(?:\/|\\)/;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildQueryName() {
+    return `fresh-import-${instanceId}`;
+}
+function buildQueryRE(queryName) {
+    return new RegExp(`(?:\\?|&)${escapeRegExp(queryName)}=(\\d+),([^&]+)(?:&|$)`);
+}
+function formatTrackingQuery(queryName, id, context) {
+    return `?${queryName}=${id},${context}`;
+}
+function trackResolved(specifier, context, result, queryName, queryRE, onDependency) {
+    const isRelativeImport = relativeImportRE.test(specifier);
+    if ("builtin" === result.format || !isRelativeImport) return result;
+    if (!context.parentURL || queryRE.test(result.url) || !result.url.startsWith("file:")) return result;
+    const m = queryRE.exec(context.parentURL);
+    if (m) {
+        const [, id, contextFile] = m;
+        onDependency(contextFile, result.url);
+        result.url = result.url.replace(/(\?)|$/, (_n, n1)=>`?${queryName}=${id},${contextFile}${"?" === n1 ? "&" : ""}`);
+    }
+    return result;
+}
+var loader_default = 'data:text/javascript,Math.random().toString(36).slice(2);%0Aconst relativeImportRE = /^\\.{1,2}(%3F:\\/|\\\\)/;%0Afunction escapeRegExp(value) {%0A%09return value.replace(/[.*+%3F^${}()|[\\]\\\\]/g, "\\\\$&");%0A}%0A/**%0A* Build the regex that matches the tracking query `%3F<name>=<id>,<context>`%0A* (or the `&<name>=...` form).%0A*/%0Afunction buildQueryRE(queryName) {%0A%09return new RegExp(`(%3F:\\\\%3F|&)${escapeRegExp(queryName)}=(\\\\d+),([^&]+)(%3F:&|$)`);%0A}%0A/**%0A* Shared body of the resolve hook for both the on-thread and off-thread%0A* importers. Given an already-resolved `result`, decides whether it is a tracked%0A* relative file dependency; if so, reports it via `onDependency` and tags the%0A* URL so the query propagates to its own dependencies.%0A*%0A* The sync/async difference between the two hooks lives entirely in the caller%0A* (which awaits `nextResolve` or not); this function performs no I/O. `result`%0A* is mutated in place and returned.%0A*/%0Afunction trackResolved(specifier, context, result, queryName, queryRE, onDependency) {%0A%09const isRelativeImport = relativeImportRE.test(specifier);%0A%09if (result.format === "builtin" || !isRelativeImport) return result;%0A%09if (!context.parentURL || queryRE.test(result.url) || !result.url.startsWith("file:")) return result;%0A%09const m = queryRE.exec(context.parentURL);%0A%09if (m) {%0A%09%09const [, id, contextFile] = m;%0A%09%09onDependency(contextFile, result.url);%0A%09%09result.url = result.url.replace(/(\\%3F)|$/, (_n, n1) => `%3F${queryName}=${id},${contextFile}${n1 === "%3F" %3F "&" : ""}`);%0A%09}%0A%09return result;%0A}%0A//%23endregion%0A//%23region src/off-thread/loader.ts%0Alet port;%0Alet queryName;%0Alet queryRE;%0Aconst initialize = async (data) => {%0A%09port = data.port;%0A%09queryName = data.queryName;%0A%09queryRE = buildQueryRE(queryName);%0A};%0Aconst resolve = async (specifier, context, nextResolve) => {%0A%09return trackResolved(specifier, context, await nextResolve(specifier, context), queryName, queryRE, (ctx, url) => {%0A%09%09port.postMessage({%0A%09%09%09context: ctx,%0A%09%09%09url%0A%09%09});%0A%09});%0A};%0A//%23endregion%0Aexport { initialize, resolve };%0A';
+let nextId$1 = 0;
+function createOffThreadImporter() {
+    const queryName = buildQueryName();
+    const { port1, port2 } = new MessageChannel();
+    Module.register(loader_default, {
+        data: {
+            port: port2,
+            queryName
+        },
+        transferList: [
+            port2
+        ]
+    });
+    port1.unref();
+    return {
+        async collect (specifier) {
+            const id = nextId$1++;
+            const depsList = /* @__PURE__ */ new Set();
+            const onMessage = (e)=>{
+                if (e.context === specifier) depsList.add(e.url);
+            };
+            port1.on("message", onMessage);
+            port1.unref();
+            try {
+                const result = await import(specifier + formatTrackingQuery(queryName, id, specifier));
+                await new Promise((resolve)=>setImmediate(resolve));
+                return {
+                    result,
+                    dependencies: [
+                        ...depsList
+                    ].filter((url)=>url.startsWith("file:")).map((url)=>fileURLToPath(url))
+                };
+            } finally{
+                port1.off("message", onMessage);
+            }
+        }
+    };
+}
+let nextId = 0;
+function createOnThreadImporter() {
+    const registry = /* @__PURE__ */ new Map();
+    const queryName = buildQueryName();
+    const queryRE = buildQueryRE(queryName);
+    const resolve = (specifier, context, nextResolve)=>trackResolved(specifier, context, nextResolve(specifier, context), queryName, queryRE, (ctx, url)=>{
+            registry.get(ctx)?.add(url);
+        });
+    Module.registerHooks({
+        resolve
+    });
+    return {
+        async collect (specifier) {
+            const id = nextId++;
+            const depsList = /* @__PURE__ */ new Set();
+            registry.set(specifier, depsList);
+            try {
+                return {
+                    result: await import(specifier + formatTrackingQuery(queryName, id, specifier)),
+                    dependencies: [
+                        ...depsList
+                    ].filter((url)=>url.startsWith("file:")).map((url)=>fileURLToPath(url))
+                };
+            } finally{
+                registry.delete(specifier);
+            }
+        }
+    };
+}
+function createImporter() {
+    if (Module.registerHooks) return createOnThreadImporter();
+    if (Module.register) return createOffThreadImporter();
+}
+let importer;
+let initialized = false;
+function freshImport(specifier) {
+    if (!initialized) {
+        importer = createImporter();
+        initialized = true;
+    }
+    return importer?.collect(specifier);
+}
+export { freshImport };

package/dist/index.js

@@ -1,4 +1,4 @@
-import node_path from "node:path";
+import node_path, { isAbsolute, join } from "node:path";
 import node_util from "node:util";
 import { rspack } from "@rspack/core";
 import node_fs from "node:fs";
@@ -854,98 +854,117 @@ 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;
+const canReadExport = (module)=>null !== module && ('object' == typeof module || 'function' == typeof module);
+const isConfigFunction = (configExport)=>'function' == typeof configExport;
+const getConfigExport = (configModule, exportName, configPath)=>{
+    if (false === exportName) return {};
+    if ('default' === exportName) return canReadExport(configModule) && 'default' in configModule ? configModule.default : configModule;
+    if (canReadExport(configModule) && Object.hasOwn(configModule, exportName)) return configModule[exportName];
+    throw new Error(`Cannot find export ${exportName} in config file: ${configPath}`);
+};
+const loadWithJiti = async (configPath, exportName, fresh)=>{
+    let createJiti;
+    try {
+        ({ createJiti } = await import("../compiled/jiti/index.js"));
+    } catch (error) {
+        throw new Error('The "jiti" package is required to load this config. Install it with your package manager.', {
+            cause: error
+        });
+    }
+    const jiti = createJiti(configPath, {
+        moduleCache: !fresh,
+        interopDefault: true,
+        nativeModules: [
+            "typescript"
+        ]
     });
-    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;
+    if ('default' === exportName) return {
+        configExport: await jiti.import(configPath, {
+            default: true
+        }),
+        dependencies: []
     };
-}
-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;
+    const configModule = await jiti.import(configPath);
+    return {
+        configExport: getConfigExport(configModule, exportName, configPath),
+        dependencies: []
+    };
+};
+const JS_CONFIG_REGEXP = /\.(?:js|mjs|cjs)$/;
+const tryFreshImport = async (configFileURL)=>{
+    try {
+        const { freshImport } = await import("./freshImport.js");
+        return await freshImport(configFileURL);
+    } catch  {}
+};
+const loadWithNative = async (configPath, fresh)=>{
+    const configFileURL = pathToFileURL(configPath).href;
+    if (!fresh) {
+        const configModule = await import(configFileURL);
+        return {
+            configModule,
+            dependencies: []
+        };
+    }
+    const freshImportResult = await tryFreshImport(configFileURL);
+    if (freshImportResult) return {
+        configModule: freshImportResult.result,
+        dependencies: freshImportResult.dependencies.sort()
+    };
+    const configModule = await import(`${configFileURL}?t=${Date.now()}`);
+    return {
+        configModule,
+        dependencies: []
+    };
+};
+const resolveConfigPath = (root, customConfig, configFileNames = [])=>{
+    if (customConfig) {
+        const customConfigPath = isAbsolute(customConfig) ? customConfig : join(root, customConfig);
+        if (node_fs.existsSync(customConfigPath)) return customConfigPath;
+        throw new Error(`Cannot find config file: ${customConfigPath}`);
+    }
+    for (const file of configFileNames){
+        const configFile = join(root, file);
+        if (node_fs.existsSync(configFile)) return configFile;
+    }
+    return null;
+};
+async function loadConfig({ cwd = process.cwd(), path, configFileNames = [], loader = 'auto', exportName = 'default', configParams = [], fresh = false } = {}) {
+    const configPath = resolveConfigPath(cwd, path, configFileNames);
+    if (!configPath) return {
+        content: {},
+        filePath: configPath,
+        dependencies: []
+    };
+    let loadedConfig;
+    const useNative = Boolean('native' === loader || 'auto' === loader && (process.features.typescript || process.versions.bun || process.versions.deno));
+    if (useNative || JS_CONFIG_REGEXP.test(configPath)) {
+        let result;
+        try {
+            result = await loadWithNative(configPath, fresh);
+        } catch (err) {
+            if ('native' === loader) throw err;
         }
-        return merge_with([
-            firstConfiguration
-        ].concat(configurations), joinArrays(options));
+        if (result) loadedConfig = {
+            configExport: getConfigExport(result.configModule, exportName, configPath),
+            dependencies: result.dependencies
+        };
+    }
+    if (!loadedConfig) loadedConfig = await loadWithJiti(configPath, exportName, fresh);
+    const { configExport, dependencies } = loadedConfig;
+    if (isConfigFunction(configExport)) {
+        const result = await configExport(...configParams);
+        if (void 0 === result) throw new Error('The config function must return a config object.');
+        return {
+            content: result,
+            filePath: configPath,
+            dependencies
+        };
+    }
+    return {
+        content: configExport,
+        filePath: configPath,
+        dependencies
     };
 }
 const DEFAULT_EXTENSIONS = [
@@ -960,71 +979,22 @@ const findConfig = (basePath)=>DEFAULT_EXTENSIONS.map((ext)=>basePath + ext).fin
 const utils_findConfig = findConfig;
 const loadConfig_require = createRequire(import.meta.url);
 const loadConfig_DEFAULT_CONFIG_NAME = 'rspack.config';
-const JS_CONFIG_EXTENSION_REGEXP = /\.(?:js|mjs|cjs)$/;
-const CONFIG_LOADER_VALUES = [
-    'auto',
-    'jiti',
-    'native'
-];
-const PREBUNDLED_JITI_PATH = new URL('../compiled/jiti/index.js', import.meta.url).href;
-const supportsNativeTypeScript = ()=>{
-    const features = process.features;
-    return Boolean(features.typescript || process.versions.bun || process.versions.deno);
-};
-const normalizeConfigLoader = (configLoader)=>{
-    const normalizedLoader = configLoader ?? 'auto';
-    if (CONFIG_LOADER_VALUES.includes(normalizedLoader)) return normalizedLoader;
-    throw new Error(`config loader "${normalizedLoader}" is not supported. Expected one of: ${CONFIG_LOADER_VALUES.join(', ')}.`);
-};
-const resolveDefaultExport = (result)=>result && 'object' == typeof result && 'default' in result ? result.default : result;
-const loadConfigWithNativeLoader = async (configPath)=>{
-    const configFileURL = pathToFileURL(configPath).href;
-    const loadedModule = await import(`${configFileURL}?t=${Date.now()}`);
-    return resolveDefaultExport(loadedModule);
-};
-let jitiInstancePromise;
-const getJiti = async ()=>{
-    if (!jitiInstancePromise) jitiInstancePromise = import(PREBUNDLED_JITI_PATH).then((module)=>{
-        const createJiti = 'createJiti' in module ? module.createJiti : module.default;
-        return createJiti(import.meta.filename, {
-            moduleCache: false,
-            interopDefault: true,
-            nativeModules: [
-                "typescript"
-            ]
-        });
-    });
-    return jitiInstancePromise;
-};
-const loadConfigWithJiti = async (configPath)=>{
-    const jiti = await getJiti();
-    return jiti.import(configPath, {
-        default: true
-    });
-};
 const loadConfigByPath = async (configPath, options)=>{
-    const configLoader = normalizeConfigLoader(options.configLoader);
-    const useNative = Boolean('native' === configLoader || 'auto' === configLoader && supportsNativeTypeScript());
-    if (useNative || JS_CONFIG_EXTENSION_REGEXP.test(configPath)) try {
-        return await loadConfigWithNativeLoader(configPath);
-    } catch (error) {
-        if ('native' === configLoader) throw error;
-    }
-    return loadConfigWithJiti(configPath);
+    const configParams = [
+        options.env,
+        options
+    ];
+    const { content } = await loadConfig({
+        path: configPath,
+        loader: options.configLoader,
+        configParams,
+        fresh: true
+    });
+    if (!isRspackConfig(content)) throw new Error(`[rspack-cli:loadConfig] The config at "${configPath}" must be an object or an array, got ${String(content)}`);
+    return content;
 };
 const isConfigObject = (value)=>Boolean(value) && 'object' == typeof value && !Array.isArray(value);
 const isRspackConfig = (value)=>Array.isArray(value) || isConfigObject(value);
-const resolveRspackConfigExport = async (configExport, options)=>{
-    let loadedConfig = configExport;
-    if ('function' == typeof loadedConfig) {
-        let functionResult = loadedConfig(options.env, options);
-        if ('function' == typeof functionResult.then) functionResult = await functionResult;
-        if (void 0 === functionResult) throw new Error('[rspack-cli:loadConfig] The config function must return a config object.');
-        loadedConfig = functionResult;
-    }
-    if (!isRspackConfig(loadedConfig)) throw new Error(`[rspack-cli:loadConfig] The config must be an object, an array, or a function that returns one, get ${String(loadedConfig)}`);
-    return loadedConfig;
-};
 const checkIsMultiRspackOptions = (config)=>Array.isArray(config);
 async function loadExtendedConfig(config, configPath, cwd, options, visitedPaths) {
     const currentVisitedPaths = visitedPaths ?? new Set();
@@ -1087,8 +1057,8 @@ async function loadExtendedConfig(config, configPath, cwd, options, visitedPaths
         }
         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, currentVisitedPaths);
+        const { merge } = await import("./rspack-merge.js");
+        const { config: extendedConfig, pathMap: extendedPathMap } = await loadExtendedConfig(loadedConfig, resolvedPath, cwd, options, currentVisitedPaths);
         const configPaths = [
             ...pathMap.get(resultConfig) || [],
             ...extendedPathMap.get(extendedConfig) || []
@@ -1149,7 +1119,7 @@ class RspackCLI {
         this.colors = this.createColors();
         this.program = program;
         program.help();
-        program.version("2.1.2");
+        program.version("2.1.4");
     }
     wrapAction(fn) {
         return (...args)=>{
@@ -1279,8 +1249,7 @@ class RspackCLI {
             pathMap: new WeakMap()
         };
         const { loadedConfig, configPath } = config;
-        const resolvedConfig = await resolveRspackConfigExport(loadedConfig, options);
-        const { config: extendedConfig, pathMap } = await loadExtendedConfig(resolvedConfig, configPath, process.cwd(), options);
+        const { config: extendedConfig, pathMap } = await loadExtendedConfig(loadedConfig, configPath, process.cwd(), options);
         return {
             config: this.filterConfig(options, extendedConfig),
             pathMap

package/dist/rspack-merge.js

@@ -0,0 +1,95 @@
+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));
+    };
+}
+export { merge };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/cli",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "description": "CLI for rspack",
   "homepage": "https://rspack.rs",
   "bugs": "https://github.com/web-infra-dev/rspack/issues",
@@ -30,7 +30,8 @@
   "devDependencies": {
     "@discoveryjs/json-ext": "^1.1.0",
     "@microsoft/api-extractor": "^7.58.9",
-    "@rslib/core": "^0.23.0",
+    "@rstackjs/load-config": "^0.1.1",
+    "@rslib/core": "^0.23.2",
     "@rspack/dev-server": "^2.1.0",
     "cac": "^7.0.0",
     "concat-stream": "^2.0.0",
@@ -41,8 +42,8 @@
     "prebundle": "^1.6.5",
     "rspack-merge": "1.0.1",
     "typescript": "^6.0.3",
-    "@rspack/core": "2.1.2",
-    "@rspack/test-tools": "2.1.2"
+    "@rspack/core": "2.1.4",
+    "@rspack/test-tools": "2.1.4"
   },
   "peerDependencies": {
     "@rspack/core": "^2.0.0-0",