@rsbuild/plugin-source-build 1.0.3 → 1.0.4

package/README.md

@@ -122,6 +122,18 @@ If the sub-project uses [exports](https://nodejs.org/api/packages.html#package-e
 }
 ```
 
+### Customizing Source Field
+
+Although the plugin uses the `source` field by default to specify the source file, we recommend configuring a custom field through the [sourceField](#sourceField) option (for example, `@custom/source`, where `custom` can be replaced with any scope name).
+
+```ts
+pluginSourceBuild({
+  sourceField: "@custom/source",
+});
+```
+
+This is because some packages (such as Mobx) also define a `source` field in their `package.json`. If not distinguished, Rsbuild may mistakenly resolve the source files of those dependencies, leading to unexpected build results or type issues. By using a custom field, you can avoid such conflicts and ensure that Rsbuild behaves predictably when resolving dependencies.
+
 ## Configure Project Reference
 
 In a TypeScript project, you need to use the capability provided by TypeScript called [Project Reference](https://typescriptlang.org/docs/handbook/project-references). It helps you develop source code more effectively.
@@ -154,7 +166,7 @@ At the same time, we need to set `composite` to `true` in the lib project's `tsc
 {
   "compilerOptions": {
     "composite": true
-  },
+  }
 }
 ```
 
@@ -173,24 +185,24 @@ Note that the above example is a simplified one. In real monorepo projects, ther
 
 Used to configure the resolve field of the source code files.
 
-For example, when configured as `my-source`:
+For example, when configured as `@custom/source`:
 
 ```ts
 pluginSourceBuild({
-  sourceField: "my-source",
+  sourceField: "@custom/source",
 });
 ```
 
-In `package.json`, the source code file path can be specified using `my-source`:
+In `package.json`, the source code file path can be specified using `@custom/source`:
 
 ```json title="package.json"
 {
   "name": "lib",
   "main": "./dist/index.js",
-  "my-source": "./src/index.ts",
+  "@custom/source": "./src/index.ts",
   "exports": {
     ".": {
-      "my-source": "./src/index.ts",
+      "@custom/source": "./src/index.ts",
       "default": "./dist/index.js"
     }
   }

package/README.zh-CN.md

@@ -120,6 +120,18 @@ monorepo
 }
 ```
 
+### 自定义 source 字段
+
+虽然插件默认使用 `source` 字段来指定源代码文件，但我们更推荐通过 [sourceField](#sourceField) 选项配置一个自定义字段（例如 `@custom/source`，其中 `custom` 可以替换为任意 scope 名称）。
+
+```ts
+pluginSourceBuild({
+  sourceField: "@custom/source",
+});
+```
+
+这是因为某些三方库（例如 Mobx）的 `package.json` 中也包含 `source` 字段，如果不进行区分，Rsbuild 可能会错误地解析这些库的源文件路径，从而导致意料之外的构建结果或类型问题。使用自定义字段可以避免此类冲突，确保 Rsbuild 在解析依赖关系时保持可控的行为。
+
 ## 配置 Project Reference
 
 在 TypeScript 项目中，你需要使用 TypeScript 提供的 [Project Reference](https://typescriptlang.org/docs/handbook/project-references) 能力，它可以帮助你更好地使用源码开发。
@@ -152,7 +164,7 @@ Project reference 提供了以下能力：
 {
   "compilerOptions": {
     "composite": true
-  },
+  }
 }
 ```
 
@@ -171,24 +183,24 @@ Project reference 提供了以下能力：
 
 用于配置源代码文件对应的解析字段。
 
-比如配置为 `my-source`：
+比如配置为 `@custom/source`：
 
 ```ts
 pluginSourceBuild({
-  sourceField: "my-source",
+  sourceField: "@custom/source",
 });
 ```
 
-在 `package.json` 中，即可通过 `my-source` 指定源代码文件的路径：
+在 `package.json` 中，即可通过 `@custom/source` 指定源代码文件的路径：
 
 ```json title="package.json"
 {
   "name": "lib",
   "main": "./dist/index.js",
-  "my-source": "./src/index.ts",
+  "@custom/source": "./src/index.ts",
   "exports": {
     ".": {
-      "my-source": "./src/index.ts",
+      "@custom/source": "./src/index.ts",
       "default": "./dist/index.js"
     }
   }

package/dist/index.cjs

@@ -1,21 +1,5 @@
 "use strict";
-var __webpack_modules__ = {
-    yaml: function(module) {
-        module.exports = import("yaml").then(function(module) {
-            return module;
-        });
-    }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
+var __webpack_require__ = {};
 (()=>{
     __webpack_require__.n = (module)=>{
         var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
@@ -47,396 +31,393 @@ function __webpack_require__(moduleId) {
     };
 })();
 var __webpack_exports__ = {};
-(()=>{
-    __webpack_require__.r(__webpack_exports__);
-    __webpack_require__.d(__webpack_exports__, {
-        Project: ()=>Project,
-        pluginSourceBuild: ()=>pluginSourceBuild,
-        getMonorepoSubProjects: ()=>getMonorepoSubProjects,
-        PLUGIN_SOURCE_BUILD_NAME: ()=>PLUGIN_SOURCE_BUILD_NAME,
-        getMonorepoBaseData: ()=>getMonorepoBaseData
-    });
-    const external_node_fs_namespaceObject = require("node:fs");
-    var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
-    const external_node_path_namespaceObject = require("node:path");
-    var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-    const external_json5_namespaceObject = require("json5");
-    var external_json5_default = /*#__PURE__*/ __webpack_require__.n(external_json5_namespaceObject);
-    const PNPM_WORKSPACE_FILE = 'pnpm-workspace.yaml';
-    const RUSH_JSON_FILE = 'rush.json';
-    const PACKAGE_JSON = 'package.json';
-    async function pathExists(path) {
-        return external_node_fs_default().promises.access(path).then(()=>true).catch(()=>false);
-    }
-    const isPnpmMonorepo = async (monorepoRootPath)=>{
-        const existPnpmWorkspaceFile = await pathExists(external_node_path_default().join(monorepoRootPath, PNPM_WORKSPACE_FILE));
-        return existPnpmWorkspaceFile;
-    };
-    const isRushMonorepo = async (monorepoRootPath)=>{
-        const existRushJsonFile = await pathExists(external_node_path_default().join(monorepoRootPath, RUSH_JSON_FILE));
-        return existRushJsonFile;
-    };
-    const isMonorepo = async (monorepoRootPath, otherMonorepoChecks)=>{
-        if ('object' == typeof otherMonorepoChecks) {
-            for (const [monorepoType, monorepoCheck] of Object.entries(otherMonorepoChecks))if ('function' == typeof monorepoCheck && await monorepoCheck(monorepoRootPath)) return {
-                isMonorepo: true,
-                type: monorepoType
-            };
-        }
-        if (await isPnpmMonorepo(monorepoRootPath)) return {
-            isMonorepo: true,
-            type: 'pnpm'
-        };
-        if (await isRushMonorepo(monorepoRootPath)) return {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Project: ()=>Project,
+    PLUGIN_SOURCE_BUILD_NAME: ()=>PLUGIN_SOURCE_BUILD_NAME,
+    getMonorepoSubProjects: ()=>getMonorepoSubProjects,
+    pluginSourceBuild: ()=>pluginSourceBuild,
+    getMonorepoBaseData: ()=>getMonorepoBaseData
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_json5_namespaceObject = require("json5");
+var external_json5_default = /*#__PURE__*/ __webpack_require__.n(external_json5_namespaceObject);
+const PNPM_WORKSPACE_FILE = 'pnpm-workspace.yaml';
+const RUSH_JSON_FILE = 'rush.json';
+const PACKAGE_JSON = 'package.json';
+async function pathExists(path) {
+    return external_node_fs_default().promises.access(path).then(()=>true).catch(()=>false);
+}
+const isPnpmMonorepo = async (monorepoRootPath)=>{
+    const existPnpmWorkspaceFile = await pathExists(external_node_path_default().join(monorepoRootPath, PNPM_WORKSPACE_FILE));
+    return existPnpmWorkspaceFile;
+};
+const isRushMonorepo = async (monorepoRootPath)=>{
+    const existRushJsonFile = await pathExists(external_node_path_default().join(monorepoRootPath, RUSH_JSON_FILE));
+    return existRushJsonFile;
+};
+const isMonorepo = async (monorepoRootPath, otherMonorepoChecks)=>{
+    if ('object' == typeof otherMonorepoChecks) {
+        for (const [monorepoType, monorepoCheck] of Object.entries(otherMonorepoChecks))if ('function' == typeof monorepoCheck && await monorepoCheck(monorepoRootPath)) return {
             isMonorepo: true,
-            type: 'rush'
-        };
-        return {
-            isMonorepo: false,
-            type: ''
+            type: monorepoType
         };
+    }
+    if (await isPnpmMonorepo(monorepoRootPath)) return {
+        isMonorepo: true,
+        type: 'pnpm'
     };
-    const getMonorepoBaseData = async (starFindPath, otherMonorepoAnalyzer)=>{
-        var _otherMonorepoAnalyzer_type;
-        let repoIsMonorepo = false;
-        let findPath = starFindPath;
-        let type = '';
-        let otherMonorepoChecks;
-        if (otherMonorepoAnalyzer) {
-            otherMonorepoChecks = otherMonorepoChecks ?? {};
-            for (const [monoType, analyzer] of Object.entries(otherMonorepoAnalyzer))otherMonorepoChecks[monoType] = analyzer.check;
-        }
-        while(true){
-            const result = await isMonorepo(findPath, otherMonorepoChecks);
-            if (result.isMonorepo) {
-                repoIsMonorepo = true;
-                ({ type } = result);
-                break;
-            }
-            if (findPath === external_node_path_default().dirname(findPath)) break;
-            findPath = external_node_path_default().dirname(findPath);
-        }
-        return {
-            isMonorepo: repoIsMonorepo,
-            rootPath: repoIsMonorepo ? findPath : '',
-            type,
-            getProjects: null == otherMonorepoAnalyzer ? void 0 : null == (_otherMonorepoAnalyzer_type = otherMonorepoAnalyzer[type]) ? void 0 : _otherMonorepoAnalyzer_type.getProjects
-        };
+    if (await isRushMonorepo(monorepoRootPath)) return {
+        isMonorepo: true,
+        type: 'rush'
     };
-    const external_fast_glob_namespaceObject = require("fast-glob");
-    var external_fast_glob_default = /*#__PURE__*/ __webpack_require__.n(external_fast_glob_namespaceObject);
-    const readPackageJson = async (pkgJsonFilePath)=>readJson(pkgJsonFilePath);
-    const readRushJson = async (rushJsonFilePath)=>{
-        const rushJson = readJson(rushJsonFilePath.includes(RUSH_JSON_FILE) ? rushJsonFilePath : external_node_path_default().join(rushJsonFilePath, RUSH_JSON_FILE));
-        return rushJson;
+    return {
+        isMonorepo: false,
+        type: ''
     };
-    async function utils_pathExists(path) {
-        return external_node_fs_default().promises.access(path).then(()=>true).catch(()=>false);
+};
+const getMonorepoBaseData = async (starFindPath, otherMonorepoAnalyzer)=>{
+    let repoIsMonorepo = false;
+    let findPath = starFindPath;
+    let type = '';
+    let otherMonorepoChecks;
+    if (otherMonorepoAnalyzer) {
+        otherMonorepoChecks = otherMonorepoChecks ?? {};
+        for (const [monoType, analyzer] of Object.entries(otherMonorepoAnalyzer))otherMonorepoChecks[monoType] = analyzer.check;
+    }
+    while(true){
+        const result = await isMonorepo(findPath, otherMonorepoChecks);
+        if (result.isMonorepo) {
+            repoIsMonorepo = true;
+            ({ type } = result);
+            break;
+        }
+        if (findPath === external_node_path_default().dirname(findPath)) break;
+        findPath = external_node_path_default().dirname(findPath);
     }
-    const readJson = async (jsonFileAbsPath)=>{
-        if (!await utils_pathExists(jsonFileAbsPath)) return {};
-        const content = await external_node_fs_default().promises.readFile(jsonFileAbsPath, 'utf-8');
-        const json = external_json5_default().parse(content);
-        return json;
+    return {
+        isMonorepo: repoIsMonorepo,
+        rootPath: repoIsMonorepo ? findPath : '',
+        type,
+        getProjects: otherMonorepoAnalyzer?.[type]?.getProjects
     };
-    function _check_private_redeclaration(obj, privateCollection) {
-        if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+};
+const external_fast_glob_namespaceObject = require("fast-glob");
+var external_fast_glob_default = /*#__PURE__*/ __webpack_require__.n(external_fast_glob_namespaceObject);
+const readPackageJson = async (pkgJsonFilePath)=>readJson(pkgJsonFilePath);
+const readRushJson = async (rushJsonFilePath)=>{
+    const rushJson = readJson(rushJsonFilePath.includes(RUSH_JSON_FILE) ? rushJsonFilePath : external_node_path_default().join(rushJsonFilePath, RUSH_JSON_FILE));
+    return rushJson;
+};
+async function utils_pathExists(path) {
+    return external_node_fs_default().promises.access(path).then(()=>true).catch(()=>false);
+}
+const readJson = async (jsonFileAbsPath)=>{
+    if (!await utils_pathExists(jsonFileAbsPath)) return {};
+    const content = await external_node_fs_default().promises.readFile(jsonFileAbsPath, 'utf-8');
+    const json = external_json5_default().parse(content);
+    return json;
+};
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+var _getExportsSourceDirs = /*#__PURE__*/ new WeakSet(), _getCommonRootPaths = /*#__PURE__*/ new WeakSet(), _getRootPath = /*#__PURE__*/ new WeakSet();
+class Project {
+    async init() {
+        this.metaData = await readPackageJson(external_node_path_default().join(this.dir, PACKAGE_JSON));
     }
-    function _class_private_method_get(receiver, privateSet, fn) {
-        if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
-        return fn;
+    getMetaData() {
+        if (null === this.metaData) throw new Error('The Project object needs to be initialized by executing the `init` function');
+        return this.metaData;
     }
-    function _class_private_method_init(obj, privateSet) {
-        _check_private_redeclaration(obj, privateSet);
-        privateSet.add(obj);
+    getDependentProjects(monorepoProjects, options) {
+        const { recursive } = options ?? {
+            recursive: false
+        };
+        const allProjectMap = new Map();
+        for (const project of monorepoProjects)allProjectMap.set(project.name, project);
+        if (!recursive) return this.getDirectDependentProjects(allProjectMap);
+        const computedSet = new Set();
+        computedSet.add(this.name);
+        const queue = this.getDirectDependentProjects(allProjectMap).filter((p)=>!computedSet.has(p.name));
+        const result = [];
+        while(queue.length > 0){
+            const item = queue.shift();
+            if (computedSet.has(item.name)) continue;
+            result.push(item);
+            computedSet.add(item.name);
+            const newDeps = item.getDirectDependentProjects(allProjectMap);
+            if (newDeps.length > 0) queue.push(...newDeps);
+        }
+        return result;
     }
-    function _define_property(obj, key, value) {
-        if (key in obj) Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-        else obj[key] = value;
-        return obj;
+    getDirectDependentProjects(allProjectMap) {
+        const pkgJson = this.getMetaData();
+        const { dependencies = {}, devDependencies = {} } = pkgJson;
+        const projects = [];
+        for (const d of Object.keys(dependencies))if (allProjectMap.has(d)) projects.push(allProjectMap.get(d));
+        for (const d of Object.keys(devDependencies))if (allProjectMap.has(d)) projects.push(allProjectMap.get(d));
+        return projects;
     }
-    var _getExportsSourceDirs = /*#__PURE__*/ new WeakSet(), _getCommonRootPaths = /*#__PURE__*/ new WeakSet(), _getRootPath = /*#__PURE__*/ new WeakSet();
-    class Project {
-        async init() {
-            this.metaData = await readPackageJson(external_node_path_default().join(this.dir, PACKAGE_JSON));
-        }
-        getMetaData() {
-            if (null === this.metaData) throw new Error('The Project object needs to be initialized by executing the `init` function');
-            return this.metaData;
-        }
-        getDependentProjects(monorepoProjects, options) {
-            const { recursive } = options ?? {
-                recursive: false
-            };
-            const allProjectMap = new Map();
-            for (const project of monorepoProjects)allProjectMap.set(project.name, project);
-            if (!recursive) return this.getDirectDependentProjects(allProjectMap);
-            const computedSet = new Set();
-            computedSet.add(this.name);
-            const queue = this.getDirectDependentProjects(allProjectMap).filter((p)=>!computedSet.has(p.name));
-            const result = [];
-            while(queue.length > 0){
-                const item = queue.shift();
-                if (computedSet.has(item.name)) continue;
-                result.push(item);
-                computedSet.add(item.name);
-                const newDeps = item.getDirectDependentProjects(allProjectMap);
-                if (newDeps.length > 0) queue.push(...newDeps);
-            }
-            return result;
-        }
-        getDirectDependentProjects(allProjectMap) {
-            const pkgJson = this.getMetaData();
-            const { dependencies = {}, devDependencies = {} } = pkgJson;
-            const projects = [];
-            for (const d of Object.keys(dependencies))if (allProjectMap.has(d)) projects.push(allProjectMap.get(d));
-            for (const d of Object.keys(devDependencies))if (allProjectMap.has(d)) projects.push(allProjectMap.get(d));
-            return projects;
-        }
-        getSourceEntryPaths(options) {
-            const { exports: checkExports = false, field: sourceField = 'source' } = options ?? {};
-            const pkgJson = this.getMetaData();
-            const sourceDirs = pkgJson[sourceField] ? [
-                external_node_path_default().normalize(pkgJson[sourceField])
-            ] : [];
-            if (checkExports) {
-                const exportsSourceDirs = _class_private_method_get(this, _getExportsSourceDirs, getExportsSourceDirs).call(this, pkgJson.exports ?? {}, sourceField);
-                sourceDirs.push(...exportsSourceDirs);
-            }
-            if (!sourceDirs.length) throw new Error(`"${sourceField}" field is not found in ${this.name} package.json`);
-            return _class_private_method_get(this, _getCommonRootPaths, getCommonRootPaths).call(this, sourceDirs);
-        }
-        constructor(name, dir){
-            _class_private_method_init(this, _getExportsSourceDirs);
-            _class_private_method_init(this, _getCommonRootPaths);
-            _class_private_method_init(this, _getRootPath);
-            _define_property(this, "name", void 0);
-            _define_property(this, "dir", void 0);
-            _define_property(this, "metaData", void 0);
-            this.name = name;
-            this.dir = dir;
+    getSourceEntryPaths(options) {
+        const { exports: checkExports = false, field: sourceField = 'source' } = options ?? {};
+        const pkgJson = this.getMetaData();
+        const sourceDirs = pkgJson[sourceField] ? [
+            external_node_path_default().normalize(pkgJson[sourceField])
+        ] : [];
+        if (checkExports) {
+            const exportsSourceDirs = _class_private_method_get(this, _getExportsSourceDirs, getExportsSourceDirs).call(this, pkgJson.exports ?? {}, sourceField);
+            sourceDirs.push(...exportsSourceDirs);
         }
+        if (!sourceDirs.length) throw new Error(`"${sourceField}" field is not found in ${this.name} package.json`);
+        return _class_private_method_get(this, _getCommonRootPaths, getCommonRootPaths).call(this, sourceDirs);
     }
-    function getExportsSourceDirs(exportsConfig, sourceField) {
-        const exportsSourceDirs = [];
-        if ('string' == typeof exportsConfig[sourceField]) exportsSourceDirs.push(external_node_path_default().normalize(exportsConfig[sourceField]));
-        for (const moduleRules of Object.values(exportsConfig))if ('object' == typeof moduleRules && 'string' == typeof moduleRules[sourceField]) exportsSourceDirs.push(external_node_path_default().normalize(moduleRules[sourceField]));
-        return exportsSourceDirs;
+    constructor(name, dir){
+        _class_private_method_init(this, _getExportsSourceDirs);
+        _class_private_method_init(this, _getCommonRootPaths);
+        _class_private_method_init(this, _getRootPath);
+        _define_property(this, "name", void 0);
+        _define_property(this, "dir", void 0);
+        _define_property(this, "metaData", void 0);
+        this.name = name;
+        this.dir = dir;
     }
-    function getCommonRootPaths(paths) {
-        const commonRootPathsSet = new Set();
-        for (const p of paths){
-            let dir;
-            try {
-                dir = external_node_fs_default().statSync(p).isDirectory() ? p : external_node_path_default().dirname(p);
-            } catch  {
-                dir = external_node_path_default().dirname(p);
-            }
-            const rootPath = _class_private_method_get(this, _getRootPath, getRootPath).call(this, dir);
-            if (!commonRootPathsSet.has(rootPath)) commonRootPathsSet.add(rootPath);
+}
+function getExportsSourceDirs(exportsConfig, sourceField) {
+    const exportsSourceDirs = [];
+    if ('string' == typeof exportsConfig[sourceField]) exportsSourceDirs.push(external_node_path_default().normalize(exportsConfig[sourceField]));
+    for (const moduleRules of Object.values(exportsConfig))if ('object' == typeof moduleRules && 'string' == typeof moduleRules[sourceField]) exportsSourceDirs.push(external_node_path_default().normalize(moduleRules[sourceField]));
+    return exportsSourceDirs;
+}
+function getCommonRootPaths(paths) {
+    const commonRootPathsSet = new Set();
+    for (const p of paths){
+        let dir;
+        try {
+            dir = external_node_fs_default().statSync(p).isDirectory() ? p : external_node_path_default().dirname(p);
+        } catch  {
+            dir = external_node_path_default().dirname(p);
         }
-        return Array.from(commonRootPathsSet).map((p)=>external_node_path_default().join(this.dir, p));
+        const rootPath = _class_private_method_get(this, _getRootPath, getRootPath).call(this, dir);
+        if (!commonRootPathsSet.has(rootPath)) commonRootPathsSet.add(rootPath);
     }
-    function getRootPath(p) {
-        return p.split(external_node_path_default().sep)[0];
-    }
-    const getPatternsFromYaml = async (monorepoRoot)=>{
-        const { parse } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "yaml"));
-        const workspaceYamlFilePath = external_node_path_default().join(monorepoRoot, PNPM_WORKSPACE_FILE);
-        const yamlContent = await external_node_fs_default().promises.readFile(workspaceYamlFilePath, 'utf8');
-        const pnpmWorkspace = parse(yamlContent);
-        return pnpmWorkspace.packages || [];
-    };
-    const normalize = (results)=>results.map((fp)=>external_node_path_default().normalize(fp));
-    const getGlobOpts = (rootPath, patterns)=>{
-        const globOpts = {
-            cwd: rootPath,
-            absolute: true,
-            followSymbolicLinks: false
-        };
-        if (patterns.some((cfg)=>cfg.includes('**') || cfg.includes('*'))) globOpts.ignore = [
-            '**/dist/**',
-            '**/node_modules/**'
-        ];
-        return globOpts;
+    return Array.from(commonRootPathsSet).map((p)=>external_node_path_default().join(this.dir, p));
+}
+function getRootPath(p) {
+    return p.split(external_node_path_default().sep)[0];
+}
+const getPatternsFromYaml = async (monorepoRoot)=>{
+    const { parse } = await import("yaml");
+    const workspaceYamlFilePath = external_node_path_default().join(monorepoRoot, PNPM_WORKSPACE_FILE);
+    const yamlContent = await external_node_fs_default().promises.readFile(workspaceYamlFilePath, 'utf8');
+    const pnpmWorkspace = parse(yamlContent);
+    return pnpmWorkspace.packages || [];
+};
+const normalize = (results)=>results.map((fp)=>external_node_path_default().normalize(fp));
+const getGlobOpts = (rootPath, patterns)=>{
+    const globOpts = {
+        cwd: rootPath,
+        absolute: true,
+        followSymbolicLinks: false
     };
-    const makeFileFinder = (rootPath, patterns)=>{
-        const globOpts = getGlobOpts(rootPath, patterns);
-        return async (fileName, fileMapper)=>{
-            let result = await external_fast_glob_default()(patterns.map((globPath)=>external_node_path_default().posix.join(globPath, fileName)), globOpts);
-            result = result.sort();
-            result = normalize(result);
-            return fileMapper(result);
-        };
+    if (patterns.some((cfg)=>cfg.includes('**') || cfg.includes('*'))) globOpts.ignore = [
+        '**/dist/**',
+        '**/node_modules/**'
+    ];
+    return globOpts;
+};
+const makeFileFinder = (rootPath, patterns)=>{
+    const globOpts = getGlobOpts(rootPath, patterns);
+    return async (fileName, fileMapper)=>{
+        let result = await external_fast_glob_default()(patterns.map((globPath)=>external_node_path_default().posix.join(globPath, fileName)), globOpts);
+        result = result.sort();
+        result = normalize(result);
+        return fileMapper(result);
     };
-    const readPnpmProjects = async (monorepoRoot, patterns)=>{
-        const finder = makeFileFinder(monorepoRoot, patterns);
-        const mapper = async (pkgJsonFilePath)=>{
-            const pkgJson = await readPackageJson(pkgJsonFilePath);
-            return {
-                dir: external_node_path_default().dirname(pkgJsonFilePath),
-                manifest: pkgJson
-            };
+};
+const readPnpmProjects = async (monorepoRoot, patterns)=>{
+    const finder = makeFileFinder(monorepoRoot, patterns);
+    const mapper = async (pkgJsonFilePath)=>{
+        const pkgJson = await readPackageJson(pkgJsonFilePath);
+        return {
+            dir: external_node_path_default().dirname(pkgJsonFilePath),
+            manifest: pkgJson
         };
-        const projects = await finder(PACKAGE_JSON, (filePaths)=>Promise.all(filePaths.map(mapper)));
-        return projects;
-    };
-    const pnpm_getProjects = async (monorepoRoot)=>{
-        const patterns = await getPatternsFromYaml(monorepoRoot);
-        const pnpmProjects = await readPnpmProjects(monorepoRoot, patterns);
-        return Promise.all(pnpmProjects.filter((p)=>p.manifest.name).map(async (p)=>{
-            const project = new Project(p.manifest.name, p.dir);
-            await project.init();
-            return project;
-        }));
-    };
-    const rush_getProjects = async (monorepoRoot)=>{
-        const rushConfiguration = await readRushJson(monorepoRoot);
-        const { projects = [] } = rushConfiguration;
-        return Promise.all(projects.map(async (p)=>{
-            const project = new Project(p.packageName, external_node_path_default().join(monorepoRoot, p.projectFolder));
-            await project.init();
-            return project;
-        }));
-    };
-    const getMonorepoSubProjects = async (monorepoBaseData)=>{
-        const { type, rootPath, getProjects } = monorepoBaseData;
-        if ('pnpm' === type) return pnpm_getProjects(rootPath);
-        if ('rush' === type) return rush_getProjects(rootPath);
-        if (getProjects) return getProjects(rootPath);
-        return [];
-    };
-    async function getDependentProjects_pathExists(path) {
-        return external_node_fs_default().promises.access(path).then(()=>true).catch(()=>false);
-    }
-    const getDependentProjects = async (projectNameOrRootPath, options)=>{
-        const { cwd = process.cwd(), recursive, filter, extraMonorepoStrategies } = options;
-        const currentProjectPkgJsonPath = external_node_path_default().join(projectNameOrRootPath, 'package.json');
-        let projectName;
-        if (await getDependentProjects_pathExists(currentProjectPkgJsonPath)) ({ name: projectName } = await readPackageJson(currentProjectPkgJsonPath));
-        else projectName = projectNameOrRootPath;
-        const monoBaseData = await getMonorepoBaseData(cwd, extraMonorepoStrategies);
-        if (!monoBaseData.isMonorepo) return [];
-        const projects = await getMonorepoSubProjects(monoBaseData);
-        const currentProject = projects.find((project)=>project.name === projectName);
-        if (!currentProject) return [];
-        let dependentProjects = currentProject.getDependentProjects(projects, {
-            recursive
-        });
-        if (filter) dependentProjects = await filter(dependentProjects);
-        return dependentProjects;
-    };
-    function hasExportsSourceField(exportsConfig, sourceField) {
-        return 'string' == typeof exportsConfig[sourceField] || Object.values(exportsConfig).some((moduleRules)=>'object' == typeof moduleRules && 'string' == typeof moduleRules[sourceField]);
-    }
-    const filterByField = (fieldName, checkExports)=>(projects)=>projects.filter((p)=>fieldName in p.metaData || checkExports && hasExportsSourceField(p.metaData.exports || {}, fieldName));
-    const PLUGIN_SOURCE_BUILD_NAME = 'rsbuild:source-build';
-    const getSourceInclude = async (options)=>{
-        const { projects, sourceField } = options;
-        const includes = [];
-        for (const project of projects)includes.push(...project.getSourceEntryPaths({
-            field: sourceField,
-            exports: true
-        }));
-        return includes;
     };
-    function pluginSourceBuild(options) {
-        const { projectName, sourceField = 'source', resolvePriority = 'source', extraMonorepoStrategies } = options ?? {};
-        return {
-            name: PLUGIN_SOURCE_BUILD_NAME,
-            setup (api) {
-                const projectRootPath = api.context.rootPath;
-                let projects;
-                api.modifyEnvironmentConfig(async (config)=>{
-                    projects = projects || await getDependentProjects(projectName || projectRootPath, {
-                        cwd: projectRootPath,
-                        recursive: true,
-                        filter: filterByField(sourceField, true),
-                        extraMonorepoStrategies
-                    });
-                    const includes = await getSourceInclude({
-                        projects,
-                        sourceField
-                    });
-                    config.source = config.source ?? {};
-                    config.source.include = [
-                        ...config.source.include ?? [],
-                        ...includes
-                    ];
+    const projects = await finder(PACKAGE_JSON, (filePaths)=>Promise.all(filePaths.map(mapper)));
+    return projects;
+};
+const pnpm_getProjects = async (monorepoRoot)=>{
+    const patterns = await getPatternsFromYaml(monorepoRoot);
+    const pnpmProjects = await readPnpmProjects(monorepoRoot, patterns);
+    return Promise.all(pnpmProjects.filter((p)=>p.manifest.name).map(async (p)=>{
+        const project = new Project(p.manifest.name, p.dir);
+        await project.init();
+        return project;
+    }));
+};
+const rush_getProjects = async (monorepoRoot)=>{
+    const rushConfiguration = await readRushJson(monorepoRoot);
+    const { projects = [] } = rushConfiguration;
+    return Promise.all(projects.map(async (p)=>{
+        const project = new Project(p.packageName, external_node_path_default().join(monorepoRoot, p.projectFolder));
+        await project.init();
+        return project;
+    }));
+};
+const getMonorepoSubProjects = async (monorepoBaseData)=>{
+    const { type, rootPath, getProjects } = monorepoBaseData;
+    if ('pnpm' === type) return pnpm_getProjects(rootPath);
+    if ('rush' === type) return rush_getProjects(rootPath);
+    if (getProjects) return getProjects(rootPath);
+    return [];
+};
+async function getDependentProjects_pathExists(path) {
+    return external_node_fs_default().promises.access(path).then(()=>true).catch(()=>false);
+}
+const getDependentProjects = async (projectNameOrRootPath, options)=>{
+    const { cwd = process.cwd(), recursive, filter, extraMonorepoStrategies } = options;
+    const currentProjectPkgJsonPath = external_node_path_default().join(projectNameOrRootPath, 'package.json');
+    let projectName;
+    if (await getDependentProjects_pathExists(currentProjectPkgJsonPath)) ({ name: projectName } = await readPackageJson(currentProjectPkgJsonPath));
+    else projectName = projectNameOrRootPath;
+    const monoBaseData = await getMonorepoBaseData(cwd, extraMonorepoStrategies);
+    if (!monoBaseData.isMonorepo) return [];
+    const projects = await getMonorepoSubProjects(monoBaseData);
+    const currentProject = projects.find((project)=>project.name === projectName);
+    if (!currentProject) return [];
+    let dependentProjects = currentProject.getDependentProjects(projects, {
+        recursive
+    });
+    if (filter) dependentProjects = await filter(dependentProjects);
+    return dependentProjects;
+};
+function hasExportsSourceField(exportsConfig, sourceField) {
+    return 'string' == typeof exportsConfig[sourceField] || Object.values(exportsConfig).some((moduleRules)=>'object' == typeof moduleRules && 'string' == typeof moduleRules[sourceField]);
+}
+const filterByField = (fieldName, checkExports)=>(projects)=>projects.filter((p)=>fieldName in p.metaData || checkExports && hasExportsSourceField(p.metaData.exports || {}, fieldName));
+const PLUGIN_SOURCE_BUILD_NAME = 'rsbuild:source-build';
+const getSourceInclude = async (options)=>{
+    const { projects, sourceField } = options;
+    const includes = [];
+    for (const project of projects)includes.push(...project.getSourceEntryPaths({
+        field: sourceField,
+        exports: true
+    }));
+    return includes;
+};
+function pluginSourceBuild(options) {
+    const { projectName, sourceField = 'source', resolvePriority = 'source', extraMonorepoStrategies } = options ?? {};
+    return {
+        name: PLUGIN_SOURCE_BUILD_NAME,
+        setup (api) {
+            const projectRootPath = api.context.rootPath;
+            let projects;
+            api.modifyEnvironmentConfig(async (config)=>{
+                projects = projects || await getDependentProjects(projectName || projectRootPath, {
+                    cwd: projectRootPath,
+                    recursive: true,
+                    filter: filterByField(sourceField, true),
+                    extraMonorepoStrategies
                 });
-                api.modifyBundlerChain((chain, { CHAIN_ID })=>{
-                    for (const ruleId of [
-                        CHAIN_ID.RULE.TS,
-                        CHAIN_ID.RULE.JS
-                    ])if (chain.module.rules.get(ruleId)) {
-                        const rule = chain.module.rule(ruleId);
-                        rule.resolve.mainFields.merge('source' === resolvePriority ? [
-                            sourceField,
-                            '...'
-                        ] : [
-                            '...',
-                            sourceField
-                        ]);
-                        rule.resolve.conditionNames.add('...').add(sourceField);
-                    }
+                const includes = await getSourceInclude({
+                    projects,
+                    sourceField
                 });
-                const getReferences = async (tsconfigPath, rspackReferences)=>{
-                    const references = new Set();
-                    for (const project of projects || []){
-                        const filePath = external_node_path_default().join(project.dir, 'tsconfig.json');
-                        if (external_node_fs_default().existsSync(filePath)) references.add(filePath);
-                    }
-                    const tsconfig = external_json5_default().parse(external_node_fs_default().readFileSync(tsconfigPath, 'utf-8'));
-                    const userReferences = [
-                        ...Array.isArray(rspackReferences) ? rspackReferences : [],
-                        ...tsconfig.references ? tsconfig.references.map((item)=>item.path).filter(Boolean) : []
-                    ];
-                    if (userReferences.length) {
-                        const baseDir = external_node_path_default().dirname(tsconfigPath);
-                        for (const item of userReferences){
-                            if (!item) continue;
-                            const absolutePath = external_node_path_default().isAbsolute(item) ? item : external_node_path_default().join(baseDir, item);
-                            references.add(absolutePath);
-                        }
+                config.source = config.source ?? {};
+                config.source.include = [
+                    ...config.source.include ?? [],
+                    ...includes
+                ];
+            });
+            api.modifyBundlerChain((chain, { CHAIN_ID })=>{
+                for (const ruleId of [
+                    CHAIN_ID.RULE.TS,
+                    CHAIN_ID.RULE.JS
+                ])if (chain.module.rules.get(ruleId)) {
+                    const rule = chain.module.rule(ruleId);
+                    rule.resolve.mainFields.merge('source' === resolvePriority ? [
+                        sourceField,
+                        '...'
+                    ] : [
+                        '...',
+                        sourceField
+                    ]);
+                    rule.resolve.conditionNames.add('...').add(sourceField);
+                }
+            });
+            const getReferences = async (tsconfigPath, rspackReferences)=>{
+                const references = new Set();
+                for (const project of projects || []){
+                    const filePath = external_node_path_default().join(project.dir, 'tsconfig.json');
+                    if (external_node_fs_default().existsSync(filePath)) references.add(filePath);
+                }
+                const tsconfig = external_json5_default().parse(external_node_fs_default().readFileSync(tsconfigPath, 'utf-8'));
+                const userReferences = [
+                    ...Array.isArray(rspackReferences) ? rspackReferences : [],
+                    ...tsconfig.references ? tsconfig.references.map((item)=>item.path).filter(Boolean) : []
+                ];
+                if (userReferences.length) {
+                    const baseDir = external_node_path_default().dirname(tsconfigPath);
+                    for (const item of userReferences){
+                        if (!item) continue;
+                        const absolutePath = external_node_path_default().isAbsolute(item) ? item : external_node_path_default().join(baseDir, item);
+                        references.add(absolutePath);
                     }
-                    references.delete(tsconfigPath);
-                    return Array.from(references);
+                }
+                references.delete(tsconfigPath);
+                return Array.from(references);
+            };
+            if ('rspack' === api.context.bundlerType) api.modifyRspackConfig(async (config, { environment })=>{
+                const { tsconfigPath } = environment;
+                if (!tsconfigPath) return;
+                config.resolve ||= {};
+                const { tsConfig = {
+                    configFile: tsconfigPath
+                } } = config.resolve;
+                const configObject = 'string' == typeof tsConfig ? {
+                    configFile: tsConfig
+                } : tsConfig;
+                const references = await getReferences(tsconfigPath, configObject.references);
+                config.resolve.tsConfig = {
+                    configFile: configObject?.configFile || tsconfigPath,
+                    references: references
                 };
-                if ('rspack' === api.context.bundlerType) api.modifyRspackConfig(async (config, { environment })=>{
-                    const { tsconfigPath } = environment;
-                    if (!tsconfigPath) return;
-                    config.resolve ||= {};
-                    const { tsConfig = {
-                        configFile: tsconfigPath
-                    } } = config.resolve;
-                    const configObject = 'string' == typeof tsConfig ? {
-                        configFile: tsConfig
-                    } : tsConfig;
-                    const references = await getReferences(tsconfigPath, configObject.references);
-                    config.resolve.tsConfig = {
-                        configFile: (null == configObject ? void 0 : configObject.configFile) || tsconfigPath,
-                        references: references
-                    };
-                });
-                else api.modifyBundlerChain(async (chain, { CHAIN_ID, environment })=>{
-                    const { TS_CONFIG_PATHS } = CHAIN_ID.RESOLVE_PLUGIN;
-                    const { tsconfigPath } = environment;
-                    if (!chain.resolve.plugins.has(TS_CONFIG_PATHS) || !tsconfigPath) return;
-                    const references = await getReferences(tsconfigPath);
-                    chain.resolve.plugin(TS_CONFIG_PATHS).tap((options)=>options.map((option)=>({
-                                ...option,
-                                references
-                            })));
-                });
-            }
-        };
-    }
-})();
+            });
+            else api.modifyBundlerChain(async (chain, { CHAIN_ID, environment })=>{
+                const { TS_CONFIG_PATHS } = CHAIN_ID.RESOLVE_PLUGIN;
+                const { tsconfigPath } = environment;
+                if (!chain.resolve.plugins.has(TS_CONFIG_PATHS) || !tsconfigPath) return;
+                const references = await getReferences(tsconfigPath);
+                chain.resolve.plugin(TS_CONFIG_PATHS).tap((options)=>options.map((option)=>({
+                            ...option,
+                            references
+                        })));
+            });
+        }
+    };
+}
 exports.PLUGIN_SOURCE_BUILD_NAME = __webpack_exports__.PLUGIN_SOURCE_BUILD_NAME;
 exports.Project = __webpack_exports__.Project;
 exports.getMonorepoBaseData = __webpack_exports__.getMonorepoBaseData;

package/dist/index.js

@@ -37,7 +37,6 @@ const isMonorepo = async (monorepoRootPath, otherMonorepoChecks)=>{
     };
 };
 const getMonorepoBaseData = async (starFindPath, otherMonorepoAnalyzer)=>{
-    var _otherMonorepoAnalyzer_type;
     let repoIsMonorepo = false;
     let findPath = starFindPath;
     let type = '';
@@ -60,7 +59,7 @@ const getMonorepoBaseData = async (starFindPath, otherMonorepoAnalyzer)=>{
         isMonorepo: repoIsMonorepo,
         rootPath: repoIsMonorepo ? findPath : '',
         type,
-        getProjects: null == otherMonorepoAnalyzer ? void 0 : null == (_otherMonorepoAnalyzer_type = otherMonorepoAnalyzer[type]) ? void 0 : _otherMonorepoAnalyzer_type.getProjects
+        getProjects: otherMonorepoAnalyzer?.[type]?.getProjects
     };
 };
 const readPackageJson = async (pkgJsonFilePath)=>readJson(pkgJsonFilePath);
@@ -357,7 +356,7 @@ function pluginSourceBuild(options) {
                 } : tsConfig;
                 const references = await getReferences(tsconfigPath, configObject.references);
                 config.resolve.tsConfig = {
-                    configFile: (null == configObject ? void 0 : configObject.configFile) || tsconfigPath,
+                    configFile: configObject?.configFile || tsconfigPath,
                     references: references
                 };
             });

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@rsbuild/plugin-source-build",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "An Rsbuild plugin to provide support for monorepo source code referencing.",
-  "repository": "https://github.com/rspack-contrib/rsbuild-plugin-source-build",
+  "repository": "https://github.com/rstackjs/rsbuild-plugin-source-build",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -36,34 +36,34 @@
   "dependencies": {
     "fast-glob": "^3.3.3",
     "json5": "^2.2.3",
-    "yaml": "^2.8.0"
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
-    "@playwright/test": "^1.54.1",
-    "@rsbuild/core": "^1.4.12",
-    "@rsbuild/plugin-react": "^1.3.4",
-    "@rsbuild/plugin-type-check": "^1.2.3",
-    "@rslib/core": "^0.11.0",
-    "@types/node": "^22.17.0",
-    "@types/react": "^19.1.9",
-    "@types/react-dom": "^19.1.7",
-    "nano-staged": "^0.8.0",
-    "playwright": "^1.54.1",
-    "react": "^19.1.1",
-    "react-dom": "^19.1.1",
+    "@playwright/test": "^1.57.0",
+    "@rsbuild/core": "^1.6.10",
+    "@rsbuild/plugin-react": "^1.4.2",
+    "@rsbuild/plugin-type-check": "^1.3.1",
+    "@rslib/core": "^0.18.2",
+    "@types/node": "^22.19.1",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "nano-staged": "^0.9.0",
+    "playwright": "^1.57.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
     "simple-git-hooks": "^2.13.1",
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@rsbuild/core": "1.x"
+    "@rsbuild/core": "^1.0.0 || ^2.0.0-0"
   },
   "peerDependenciesMeta": {
     "@rsbuild/core": {
       "optional": true
     }
   },
-  "packageManager": "pnpm@10.14.0",
+  "packageManager": "pnpm@10.24.0",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"