@rsbuild/plugin-source-build 0.7.0-beta.2 → 0.7.0-beta.4

package/dist/index.cjs

@@ -5,6 +5,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,19 +30,492 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+// src/constants.ts
+var PNPM_WORKSPACE_FILE, RUSH_JSON_FILE, PACKAGE_JSON;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
+    RUSH_JSON_FILE = "rush.json";
+    PACKAGE_JSON = "package.json";
+  }
+});
+
+// src/utils.ts
+var import_node_path3, import_shared2, import_json5, readPackageJson, readRushJson, readJson;
+var init_utils = __esm({
+  "src/utils.ts"() {
+    "use strict";
+    import_node_path3 = __toESM(require("path"));
+    import_shared2 = require("@rsbuild/shared");
+    import_json5 = __toESM(require("@rsbuild/shared/json5"));
+    init_constants();
+    readPackageJson = async (pkgJsonFilePath) => {
+      return readJson(pkgJsonFilePath);
+    };
+    readRushJson = async (rushJsonFilePath) => {
+      const rushJson = readJson(
+        rushJsonFilePath.includes(RUSH_JSON_FILE) ? rushJsonFilePath : import_node_path3.default.join(rushJsonFilePath, RUSH_JSON_FILE)
+      );
+      return rushJson;
+    };
+    readJson = async (jsonFileAbsPath) => {
+      if (!await import_shared2.fse.pathExists(jsonFileAbsPath)) {
+        return {};
+      }
+      const content = await import_shared2.fse.readFile(jsonFileAbsPath, "utf-8");
+      const json = import_json5.default.parse(content);
+      return json;
+    };
+  }
+});
+
+// src/project/project.ts
+var import_node_fs, import_node_path4, _getExportsSourceDirs, getExportsSourceDirs_fn, _getCommonRootPaths, getCommonRootPaths_fn, _getRootPath, getRootPath_fn, Project;
+var init_project = __esm({
+  "src/project/project.ts"() {
+    "use strict";
+    import_node_fs = __toESM(require("fs"));
+    import_node_path4 = __toESM(require("path"));
+    init_constants();
+    init_utils();
+    Project = class {
+      constructor(name, dir) {
+        __privateAdd(this, _getExportsSourceDirs);
+        /**
+         *
+         * @param paths normalize paths
+         * @returns common root paths
+         */
+        __privateAdd(this, _getCommonRootPaths);
+        __privateAdd(this, _getRootPath);
+        __publicField(this, "name");
+        __publicField(this, "dir");
+        __publicField(this, "metaData");
+        this.name = name;
+        this.dir = dir;
+      }
+      async init() {
+        this.metaData = await readPackageJson(import_node_path4.default.join(this.dir, PACKAGE_JSON));
+      }
+      getMetaData() {
+        if (this.metaData === null) {
+          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 = /* @__PURE__ */ new Map();
+        for (const project of monorepoProjects) {
+          allProjectMap.set(project.name, project);
+        }
+        if (!recursive) {
+          return this.getDirectDependentProjects(allProjectMap);
+        }
+        const computedSet = /* @__PURE__ */ 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] ? [import_node_path4.default.normalize(pkgJson[sourceField])] : [];
+        if (checkExports) {
+          const exportsSourceDirs = __privateMethod(this, _getExportsSourceDirs, getExportsSourceDirs_fn).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 __privateMethod(this, _getCommonRootPaths, getCommonRootPaths_fn).call(this, sourceDirs);
+      }
+    };
+    _getExportsSourceDirs = new WeakSet();
+    getExportsSourceDirs_fn = function(exportsConfig, sourceField) {
+      const exportsSourceDirs = [];
+      for (const moduleRules of Object.values(exportsConfig)) {
+        if (typeof moduleRules === "object" && typeof moduleRules[sourceField] === "string") {
+          exportsSourceDirs.push(
+            import_node_path4.default.normalize(moduleRules[sourceField])
+          );
+        }
+      }
+      return exportsSourceDirs;
+    };
+    _getCommonRootPaths = new WeakSet();
+    getCommonRootPaths_fn = function(paths) {
+      const commonRootPathsSet = /* @__PURE__ */ new Set();
+      for (const p of paths) {
+        let dir;
+        try {
+          dir = import_node_fs.default.statSync(p).isDirectory() ? p : import_node_path4.default.dirname(p);
+        } catch {
+          dir = import_node_path4.default.dirname(p);
+        }
+        const rootPath = __privateMethod(this, _getRootPath, getRootPath_fn).call(this, dir);
+        if (!commonRootPathsSet.has(rootPath)) {
+          commonRootPathsSet.add(rootPath);
+        }
+      }
+      return Array.from(commonRootPathsSet).map((p) => import_node_path4.default.join(this.dir, p));
+    };
+    _getRootPath = new WeakSet();
+    getRootPath_fn = function(p) {
+      return p.split(import_node_path4.default.sep)[0];
+    };
+  }
+});
+
+// src/common/pnpm.ts
+var pnpm_exports = {};
+__export(pnpm_exports, {
+  getPatternsFromYaml: () => getPatternsFromYaml,
+  getProjects: () => getProjects,
+  makeFileFinder: () => makeFileFinder,
+  normalize: () => normalize,
+  readPnpmProjects: () => readPnpmProjects
+});
+var import_node_path5, import_shared3, import_yaml, import_fast_glob, getPatternsFromYaml, normalize, getGlobOpts, makeFileFinder, readPnpmProjects, getProjects;
+var init_pnpm = __esm({
+  "src/common/pnpm.ts"() {
+    "use strict";
+    import_node_path5 = __toESM(require("path"));
+    import_shared3 = require("@rsbuild/shared");
+    import_yaml = require("@rsbuild/shared/yaml");
+    import_fast_glob = __toESM(require("fast-glob"));
+    init_constants();
+    init_project();
+    init_utils();
+    getPatternsFromYaml = async (monorepoRoot) => {
+      const workspaceYamlFilePath = import_node_path5.default.join(monorepoRoot, PNPM_WORKSPACE_FILE);
+      const yamlContent = await import_shared3.fse.readFile(workspaceYamlFilePath, "utf8");
+      const pnpmWorkspace = (0, import_yaml.parse)(yamlContent);
+      return pnpmWorkspace.packages || [];
+    };
+    normalize = (results) => results.map((fp) => import_node_path5.default.normalize(fp));
+    getGlobOpts = (rootPath, patterns) => {
+      const globOpts = {
+        cwd: rootPath,
+        absolute: true,
+        followSymbolicLinks: false
+      };
+      if (patterns.some((cfg) => cfg.includes("**") || cfg.includes("*"))) {
+        globOpts.ignore = [
+          // allow globs like "packages/**" or "packages/*",
+          // but avoid picking up node_modules/**/package.json and dist/**/package.json
+          "**/dist/**",
+          "**/node_modules/**"
+        ];
+      }
+      return globOpts;
+    };
+    makeFileFinder = (rootPath, patterns) => {
+      const globOpts = getGlobOpts(rootPath, patterns);
+      return async (fileName, fileMapper) => {
+        let result = await (0, import_fast_glob.default)(
+          patterns.map((globPath) => import_node_path5.default.posix.join(globPath, fileName)),
+          globOpts
+        );
+        result = result.sort();
+        result = normalize(result);
+        return fileMapper(result);
+      };
+    };
+    readPnpmProjects = async (monorepoRoot, patterns) => {
+      const finder = makeFileFinder(monorepoRoot, patterns);
+      const mapper = async (pkgJsonFilePath) => {
+        const pkgJson = await readPackageJson(pkgJsonFilePath);
+        return {
+          dir: import_node_path5.default.dirname(pkgJsonFilePath),
+          manifest: pkgJson
+        };
+      };
+      const projects = await finder(
+        PACKAGE_JSON,
+        (filePaths) => Promise.all(filePaths.map(mapper))
+      );
+      return projects;
+    };
+    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;
+        })
+      );
+    };
+  }
+});
+
+// src/common/rush.ts
+var rush_exports = {};
+__export(rush_exports, {
+  getProjects: () => getProjects2
+});
+var import_node_path6, getProjects2;
+var init_rush = __esm({
+  "src/common/rush.ts"() {
+    "use strict";
+    import_node_path6 = __toESM(require("path"));
+    init_project();
+    init_utils();
+    getProjects2 = async (monorepoRoot) => {
+      const rushConfiguration = await readRushJson(monorepoRoot);
+      const { projects = [] } = rushConfiguration;
+      return Promise.all(
+        projects.map(async (p) => {
+          const project = new Project(
+            p.packageName,
+            import_node_path6.default.join(monorepoRoot, p.projectFolder)
+          );
+          await project.init();
+          return project;
+        })
+      );
+    };
+  }
+});
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
   PLUGIN_SOURCE_BUILD_NAME: () => PLUGIN_SOURCE_BUILD_NAME,
-  getSourceInclude: () => getSourceInclude,
+  Project: () => Project,
+  getMonorepoBaseData: () => getMonorepoBaseData,
+  getMonorepoSubProjects: () => getMonorepoSubProjects,
   pluginSourceBuild: () => pluginSourceBuild
 });
 module.exports = __toCommonJS(src_exports);
-var import_node_fs = __toESM(require("fs"));
+
+// src/plugin.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path8 = __toESM(require("path"));
+var import_shared5 = require("@rsbuild/shared");
+
+// src/project-utils/getDependentProjects.ts
+var import_node_path7 = __toESM(require("path"));
+var import_shared4 = require("@rsbuild/shared");
+
+// src/common/getBaseData.ts
+var import_node_path2 = __toESM(require("path"));
+
+// src/common/isMonorepo.ts
 var import_node_path = __toESM(require("path"));
-var import_monorepo_utils = require("@rsbuild/monorepo-utils");
 var import_shared = require("@rsbuild/shared");
+init_constants();
+var isPnpmMonorepo = async (monorepoRootPath) => {
+  const existPnpmWorkspaceFile = await import_shared.fse.pathExists(
+    import_node_path.default.join(monorepoRootPath, PNPM_WORKSPACE_FILE)
+  );
+  return existPnpmWorkspaceFile;
+};
+var isRushMonorepo = async (monorepoRootPath) => {
+  const existRushJsonFile = await import_shared.fse.pathExists(
+    import_node_path.default.join(monorepoRootPath, RUSH_JSON_FILE)
+  );
+  return existRushJsonFile;
+};
+var isMonorepo = async (monorepoRootPath, otherMonorepoChecks) => {
+  if (typeof otherMonorepoChecks === "object") {
+    for (const [monorepoType, monorepoCheck] of Object.entries(
+      otherMonorepoChecks
+    )) {
+      if (typeof monorepoCheck === "function" && await monorepoCheck(monorepoRootPath)) {
+        return {
+          isMonorepo: true,
+          type: monorepoType
+        };
+      }
+    }
+  }
+  if (await isPnpmMonorepo(monorepoRootPath)) {
+    return {
+      isMonorepo: true,
+      type: "pnpm"
+    };
+  }
+  if (await isRushMonorepo(monorepoRootPath)) {
+    return {
+      isMonorepo: true,
+      type: "rush"
+    };
+  }
+  return {
+    isMonorepo: false,
+    type: ""
+  };
+};
+
+// src/common/getBaseData.ts
+var 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 === import_node_path2.default.dirname(findPath)) {
+      break;
+    }
+    findPath = import_node_path2.default.dirname(findPath);
+  }
+  return {
+    isMonorepo: repoIsMonorepo,
+    rootPath: repoIsMonorepo ? findPath : "",
+    type,
+    getProjects: otherMonorepoAnalyzer?.[type]?.getProjects
+  };
+};
+
+// src/common/getProjects.ts
+var getMonorepoSubProjects = async (monorepoBaseData) => {
+  const { type, rootPath, getProjects: getProjects3 } = monorepoBaseData;
+  if (type === "pnpm") {
+    const { getProjects: getPnpmMonorepoSubProjects } = await Promise.resolve().then(() => (init_pnpm(), pnpm_exports));
+    return getPnpmMonorepoSubProjects(rootPath);
+  }
+  if (type === "rush") {
+    const { getProjects: getRushMonorepoSubProjects } = await Promise.resolve().then(() => (init_rush(), rush_exports));
+    return getRushMonorepoSubProjects(rootPath);
+  }
+  if (getProjects3) {
+    return getProjects3(rootPath);
+  }
+  return [];
+};
+
+// src/common/index.ts
+init_pnpm();
+init_rush();
+
+// src/project-utils/getDependentProjects.ts
+init_utils();
+
+// src/project-utils/filter.ts
+function hasExportsSourceField(exportsConfig, sourceField) {
+  return Object.values(exportsConfig).some(
+    (moduleRules) => typeof moduleRules === "object" && typeof moduleRules[sourceField] === "string"
+  );
+}
+var defaultFilter = (projects) => projects;
+var filterByField = (fieldName, checkExports) => (projects) => {
+  return projects.filter((p) => {
+    return fieldName in p.metaData || checkExports && hasExportsSourceField(p.metaData.exports || {}, fieldName);
+  });
+};
+
+// src/project-utils/getDependentProjects.ts
+var filterProjects = async (projects, filter) => {
+  if (!filter) {
+    return defaultFilter(projects);
+  }
+  return filter(projects);
+};
+var getDependentProjects = async (projectNameOrRootPath, options) => {
+  const {
+    cwd = process.cwd(),
+    recursive,
+    filter,
+    extraMonorepoStrategies
+  } = options;
+  const currentProjectPkgJsonPath = import_node_path7.default.join(
+    projectNameOrRootPath,
+    "package.json"
+  );
+  let projectName;
+  if (await import_shared4.fse.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
+  });
+  dependentProjects = await filterProjects(dependentProjects, filter);
+  return dependentProjects;
+};
+
+// src/plugin.ts
 var PLUGIN_SOURCE_BUILD_NAME = "rsbuild:source-build";
 var getSourceInclude = async (options) => {
   const { projects, sourceField } = options;
@@ -63,10 +540,10 @@ function pluginSourceBuild(options) {
       const projectRootPath = api.context.rootPath;
       let projects = [];
       api.modifyRsbuildConfig(async (config) => {
-        projects = await (0, import_monorepo_utils.getDependentProjects)(projectName || projectRootPath, {
+        projects = await getDependentProjects(projectName || projectRootPath, {
           cwd: projectRootPath,
           recursive: true,
-          filter: (0, import_monorepo_utils.filterByField)(sourceField, true),
+          filter: filterByField(sourceField, true),
           extraMonorepoStrategies
         });
         const includes = await getSourceInclude({
@@ -92,11 +569,11 @@ function pluginSourceBuild(options) {
         }
       });
       const getReferences = async () => {
-        const refers = projects.map((project) => import_node_path.default.join(project.dir, import_shared.TS_CONFIG_FILE)).filter((filePath) => import_node_fs.default.existsSync(filePath));
+        const refers = projects.map((project) => import_node_path8.default.join(project.dir, import_shared5.TS_CONFIG_FILE)).filter((filePath) => import_node_fs2.default.existsSync(filePath));
         if (api.context.tsconfigPath) {
-          const { default: json5 } = await import("@rsbuild/shared/json5");
-          const { references } = json5.parse(
-            import_shared.fse.readFileSync(api.context.tsconfigPath, "utf-8")
+          const { default: json52 } = await import("@rsbuild/shared/json5");
+          const { references } = json52.parse(
+            import_shared5.fse.readFileSync(api.context.tsconfigPath, "utf-8")
           );
           return Array.isArray(references) ? references.map((r) => r.path).filter(Boolean).concat(refers) : refers;
         }
@@ -132,9 +609,14 @@ function pluginSourceBuild(options) {
     }
   };
 }
+
+// src/project/index.ts
+init_project();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PLUGIN_SOURCE_BUILD_NAME,
-  getSourceInclude,
+  Project,
+  getMonorepoBaseData,
+  getMonorepoSubProjects,
   pluginSourceBuild
 });

package/dist/index.d.ts

@@ -1,11 +1,193 @@
 import { RsbuildPlugin } from '@rsbuild/core';
-import { Project, ExtraMonorepoStrategies } from '@rsbuild/monorepo-utils';
+
+/**
+ * The following code is modified based on
+ * https://github.com/microsoft/rushstack/blob/main/libraries/node-core-library/src/IPackageJson.ts
+ *
+ * MIT Licensed
+ * Copyright (c) Microsoft Corporation
+ * https://github.com/microsoft/rushstack/blob/main/LICENSE
+ */
+/**
+ * This interface is part of the {@link IPackageJson} file format.  It is used for the
+ * "dependencies", "optionalDependencies", and "devDependencies" fields.
+ * @public
+ */
+interface IPackageJsonDependencyTable {
+    /**
+     * The key is the name of a dependency.  The value is a Semantic Versioning (SemVer)
+     * range specifier.
+     */
+    [dependencyName: string]: string;
+}
+interface IPackageJsonRepository {
+    /**
+     * The source control type for the repository that hosts the project. This is typically "git".
+     */
+    type: string;
+    /**
+     * The URL of the repository that hosts the project.
+     */
+    url: string;
+    /**
+     * If the project does not exist at the root of the repository, its path is specified here.
+     */
+    directory?: string;
+}
+/**
+ * This interface is part of the {@link IPackageJson} file format.  It is used for the
+ * "scripts" field.
+ * @public
+ */
+interface IPackageJsonScriptTable {
+    /**
+     * The key is the name of the script hook.  The value is the script body which may
+     * be a file path or shell script command.
+     */
+    [scriptName: string]: string;
+}
+/**
+ * This interface is part of the {@link IPackageJson} file format. It is used for the
+ * "peerDependenciesMeta" field.
+ * @public
+ */
+interface IPeerDependenciesMetaTable {
+    [dependencyName: string]: {
+        optional?: boolean;
+    };
+}
+type ExportsModuleRules = string | Record<string, string> | Record<string, string | Record<string, string>>;
+interface ExportsConfig {
+    [modulePath: string]: ExportsModuleRules;
+}
+interface INodePackageJson {
+    /**
+     * The name of the package.
+     */
+    name: string;
+    /**
+     * A version number conforming to the Semantic Versioning (SemVer) standard.
+     */
+    version?: string;
+    /**
+     * Indicates whether this package is allowed to be published or not.
+     */
+    private?: boolean;
+    /**
+     * A brief description of the package.
+     */
+    description?: string;
+    /**
+     * The URL of the project's repository.
+     */
+    repository?: string | IPackageJsonRepository;
+    /**
+     * The URL to the project's web page.
+     */
+    homepage?: string;
+    /**
+     * The name of the license.
+     */
+    license?: string;
+    /**
+     * The path to the module file that will act as the main entry point.
+     */
+    main?: string;
+    exports?: ExportsConfig;
+    /**
+     * The path to the TypeScript *.d.ts file describing the module file
+     * that will act as the main entry point.
+     */
+    types?: string;
+    /**
+     * Alias for `types`
+     */
+    typings?: string;
+    /**
+     * The path to the TSDoc metadata file.
+     * This is still being standardized: https://github.com/microsoft/tsdoc/issues/7#issuecomment-442271815
+     * @beta
+     */
+    tsdocMetadata?: string;
+    /**
+     * The main entry point for the package.
+     */
+    bin?: string;
+    /**
+     * An array of dependencies that must always be installed for this package.
+     */
+    dependencies?: IPackageJsonDependencyTable;
+    /**
+     * An array of optional dependencies that may be installed for this package.
+     */
+    optionalDependencies?: IPackageJsonDependencyTable;
+    /**
+     * An array of dependencies that must only be installed for developers who will
+     * build this package.
+     */
+    devDependencies?: IPackageJsonDependencyTable;
+    /**
+     * An array of dependencies that must be installed by a consumer of this package,
+     * but which will not be automatically installed by this package.
+     */
+    peerDependencies?: IPackageJsonDependencyTable;
+    /**
+     * An array of metadata about peer dependencies.
+     */
+    peerDependenciesMeta?: IPeerDependenciesMetaTable;
+    /**
+     * A table of script hooks that a package manager or build tool may invoke.
+     */
+    scripts?: IPackageJsonScriptTable;
+    /**
+     * A table of package version resolutions. This feature is only implemented by the Yarn package manager.
+     *
+     * @remarks
+     * See the {@link https://github.com/yarnpkg/rfcs/blob/master/implemented/0000-selective-versions-resolutions.md
+     * | 0000-selective-versions-resolutions.md RFC} for details.
+     */
+    resolutions?: Record<string, string>;
+}
+
+declare class Project {
+    #private;
+    name: string;
+    dir: string;
+    metaData: INodePackageJson;
+    constructor(name: string, dir: string);
+    init(): Promise<void>;
+    getMetaData(): INodePackageJson;
+    getDependentProjects(monorepoProjects: Project[], options?: {
+        recursive?: boolean;
+    }): Project[];
+    getDirectDependentProjects(allProjectMap: Map<string, Project>): Project[];
+    getSourceEntryPaths(options?: {
+        field?: string;
+        exports?: boolean;
+    }): string[];
+}
+
+interface IMonorepoBaseData {
+    isMonorepo: boolean;
+    type: string;
+    rootPath: string;
+    getProjects?: GetProjectsFunc;
+}
+declare const getMonorepoBaseData: (starFindPath: string, otherMonorepoAnalyzer?: Record<string, MonorepoAnalyzer>) => Promise<IMonorepoBaseData>;
+
+type GetProjectsFunc = (rootPath: string) => Promise<Project[]> | Project[];
+declare const getMonorepoSubProjects: (monorepoBaseData: IMonorepoBaseData) => Promise<Project[]>;
+
+type IsMonorepoFn = (monorepoRootPath: string) => Promise<boolean> | boolean;
+
+interface MonorepoAnalyzer {
+    check: IsMonorepoFn;
+    getProjects: GetProjectsFunc;
+}
+
+type ExtraMonorepoStrategies = Record<string, MonorepoAnalyzer>;
 
 declare const PLUGIN_SOURCE_BUILD_NAME = "rsbuild:source-build";
-declare const getSourceInclude: (options: {
-    projects: Project[];
-    sourceField: string;
-}) => Promise<string[]>;
 interface PluginSourceBuildOptions {
     /**
      * Used to configure the resolve field of the source code files.
@@ -22,4 +204,4 @@ interface PluginSourceBuildOptions {
 }
 declare function pluginSourceBuild(options?: PluginSourceBuildOptions): RsbuildPlugin;
 
-export { PLUGIN_SOURCE_BUILD_NAME, type PluginSourceBuildOptions, getSourceInclude, pluginSourceBuild };
+export { type MonorepoAnalyzer, PLUGIN_SOURCE_BUILD_NAME, type PluginSourceBuildOptions, Project, getMonorepoBaseData, getMonorepoSubProjects, pluginSourceBuild };

package/dist/index.js

@@ -1,19 +1,520 @@
 import { createRequire } from 'module';
 var require = createRequire(import.meta['url']);
 
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 
 // ../../node_modules/.pnpm/@modern-js+module-tools@2.49.3_eslint@8.57.0_typescript@5.4.5/node_modules/@modern-js/module-tools/shims/esm.js
 import { fileURLToPath } from "url";
 import path from "path";
+var init_esm = __esm({
+  "../../node_modules/.pnpm/@modern-js+module-tools@2.49.3_eslint@8.57.0_typescript@5.4.5/node_modules/@modern-js/module-tools/shims/esm.js"() {
+    "use strict";
+  }
+});
 
-// src/index.ts
+// src/constants.ts
+var PNPM_WORKSPACE_FILE, RUSH_JSON_FILE, PACKAGE_JSON;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    init_esm();
+    PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
+    RUSH_JSON_FILE = "rush.json";
+    PACKAGE_JSON = "package.json";
+  }
+});
+
+// src/utils.ts
+import path4 from "path";
+import { fse as fse2 } from "@rsbuild/shared";
+import json5 from "@rsbuild/shared/json5";
+var readPackageJson, readRushJson, readJson;
+var init_utils = __esm({
+  "src/utils.ts"() {
+    "use strict";
+    init_esm();
+    init_constants();
+    readPackageJson = async (pkgJsonFilePath) => {
+      return readJson(pkgJsonFilePath);
+    };
+    readRushJson = async (rushJsonFilePath) => {
+      const rushJson = readJson(
+        rushJsonFilePath.includes(RUSH_JSON_FILE) ? rushJsonFilePath : path4.join(rushJsonFilePath, RUSH_JSON_FILE)
+      );
+      return rushJson;
+    };
+    readJson = async (jsonFileAbsPath) => {
+      if (!await fse2.pathExists(jsonFileAbsPath)) {
+        return {};
+      }
+      const content = await fse2.readFile(jsonFileAbsPath, "utf-8");
+      const json = json5.parse(content);
+      return json;
+    };
+  }
+});
+
+// src/project/project.ts
 import fs from "fs";
+import path5 from "path";
+var _getExportsSourceDirs, getExportsSourceDirs_fn, _getCommonRootPaths, getCommonRootPaths_fn, _getRootPath, getRootPath_fn, Project;
+var init_project = __esm({
+  "src/project/project.ts"() {
+    "use strict";
+    init_esm();
+    init_constants();
+    init_utils();
+    Project = class {
+      constructor(name, dir) {
+        __privateAdd(this, _getExportsSourceDirs);
+        /**
+         *
+         * @param paths normalize paths
+         * @returns common root paths
+         */
+        __privateAdd(this, _getCommonRootPaths);
+        __privateAdd(this, _getRootPath);
+        __publicField(this, "name");
+        __publicField(this, "dir");
+        __publicField(this, "metaData");
+        this.name = name;
+        this.dir = dir;
+      }
+      async init() {
+        this.metaData = await readPackageJson(path5.join(this.dir, PACKAGE_JSON));
+      }
+      getMetaData() {
+        if (this.metaData === null) {
+          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 = /* @__PURE__ */ new Map();
+        for (const project of monorepoProjects) {
+          allProjectMap.set(project.name, project);
+        }
+        if (!recursive) {
+          return this.getDirectDependentProjects(allProjectMap);
+        }
+        const computedSet = /* @__PURE__ */ 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] ? [path5.normalize(pkgJson[sourceField])] : [];
+        if (checkExports) {
+          const exportsSourceDirs = __privateMethod(this, _getExportsSourceDirs, getExportsSourceDirs_fn).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 __privateMethod(this, _getCommonRootPaths, getCommonRootPaths_fn).call(this, sourceDirs);
+      }
+    };
+    _getExportsSourceDirs = new WeakSet();
+    getExportsSourceDirs_fn = function(exportsConfig, sourceField) {
+      const exportsSourceDirs = [];
+      for (const moduleRules of Object.values(exportsConfig)) {
+        if (typeof moduleRules === "object" && typeof moduleRules[sourceField] === "string") {
+          exportsSourceDirs.push(
+            path5.normalize(moduleRules[sourceField])
+          );
+        }
+      }
+      return exportsSourceDirs;
+    };
+    _getCommonRootPaths = new WeakSet();
+    getCommonRootPaths_fn = function(paths) {
+      const commonRootPathsSet = /* @__PURE__ */ new Set();
+      for (const p of paths) {
+        let dir;
+        try {
+          dir = fs.statSync(p).isDirectory() ? p : path5.dirname(p);
+        } catch {
+          dir = path5.dirname(p);
+        }
+        const rootPath = __privateMethod(this, _getRootPath, getRootPath_fn).call(this, dir);
+        if (!commonRootPathsSet.has(rootPath)) {
+          commonRootPathsSet.add(rootPath);
+        }
+      }
+      return Array.from(commonRootPathsSet).map((p) => path5.join(this.dir, p));
+    };
+    _getRootPath = new WeakSet();
+    getRootPath_fn = function(p) {
+      return p.split(path5.sep)[0];
+    };
+  }
+});
+
+// src/common/pnpm.ts
+var pnpm_exports = {};
+__export(pnpm_exports, {
+  getPatternsFromYaml: () => getPatternsFromYaml,
+  getProjects: () => getProjects,
+  makeFileFinder: () => makeFileFinder,
+  normalize: () => normalize,
+  readPnpmProjects: () => readPnpmProjects
+});
+import path6 from "path";
+import { fse as fse3 } from "@rsbuild/shared";
+import { parse } from "@rsbuild/shared/yaml";
+import glob from "fast-glob";
+var getPatternsFromYaml, normalize, getGlobOpts, makeFileFinder, readPnpmProjects, getProjects;
+var init_pnpm = __esm({
+  "src/common/pnpm.ts"() {
+    "use strict";
+    init_esm();
+    init_constants();
+    init_project();
+    init_utils();
+    getPatternsFromYaml = async (monorepoRoot) => {
+      const workspaceYamlFilePath = path6.join(monorepoRoot, PNPM_WORKSPACE_FILE);
+      const yamlContent = await fse3.readFile(workspaceYamlFilePath, "utf8");
+      const pnpmWorkspace = parse(yamlContent);
+      return pnpmWorkspace.packages || [];
+    };
+    normalize = (results) => results.map((fp) => path6.normalize(fp));
+    getGlobOpts = (rootPath, patterns) => {
+      const globOpts = {
+        cwd: rootPath,
+        absolute: true,
+        followSymbolicLinks: false
+      };
+      if (patterns.some((cfg) => cfg.includes("**") || cfg.includes("*"))) {
+        globOpts.ignore = [
+          // allow globs like "packages/**" or "packages/*",
+          // but avoid picking up node_modules/**/package.json and dist/**/package.json
+          "**/dist/**",
+          "**/node_modules/**"
+        ];
+      }
+      return globOpts;
+    };
+    makeFileFinder = (rootPath, patterns) => {
+      const globOpts = getGlobOpts(rootPath, patterns);
+      return async (fileName, fileMapper) => {
+        let result = await glob(
+          patterns.map((globPath) => path6.posix.join(globPath, fileName)),
+          globOpts
+        );
+        result = result.sort();
+        result = normalize(result);
+        return fileMapper(result);
+      };
+    };
+    readPnpmProjects = async (monorepoRoot, patterns) => {
+      const finder = makeFileFinder(monorepoRoot, patterns);
+      const mapper = async (pkgJsonFilePath) => {
+        const pkgJson = await readPackageJson(pkgJsonFilePath);
+        return {
+          dir: path6.dirname(pkgJsonFilePath),
+          manifest: pkgJson
+        };
+      };
+      const projects = await finder(
+        PACKAGE_JSON,
+        (filePaths) => Promise.all(filePaths.map(mapper))
+      );
+      return projects;
+    };
+    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;
+        })
+      );
+    };
+  }
+});
+
+// src/common/rush.ts
+var rush_exports = {};
+__export(rush_exports, {
+  getProjects: () => getProjects2
+});
+import path7 from "path";
+var getProjects2;
+var init_rush = __esm({
+  "src/common/rush.ts"() {
+    "use strict";
+    init_esm();
+    init_project();
+    init_utils();
+    getProjects2 = async (monorepoRoot) => {
+      const rushConfiguration = await readRushJson(monorepoRoot);
+      const { projects = [] } = rushConfiguration;
+      return Promise.all(
+        projects.map(async (p) => {
+          const project = new Project(
+            p.packageName,
+            path7.join(monorepoRoot, p.projectFolder)
+          );
+          await project.init();
+          return project;
+        })
+      );
+    };
+  }
+});
+
+// src/index.ts
+init_esm();
+
+// src/plugin.ts
+init_esm();
+import fs2 from "fs";
+import path9 from "path";
+import { TS_CONFIG_FILE, fse as fse5 } from "@rsbuild/shared";
+
+// src/project-utils/index.ts
+init_esm();
+
+// src/project-utils/getDependentProjects.ts
+init_esm();
+import path8 from "path";
+import { fse as fse4 } from "@rsbuild/shared";
+
+// src/common/index.ts
+init_esm();
+
+// src/common/getBaseData.ts
+init_esm();
+import path3 from "path";
+
+// src/common/isMonorepo.ts
+init_esm();
+init_constants();
 import path2 from "path";
-import {
-  filterByField,
-  getDependentProjects
-} from "@rsbuild/monorepo-utils";
-import { TS_CONFIG_FILE, fse } from "@rsbuild/shared";
+import { fse } from "@rsbuild/shared";
+var isPnpmMonorepo = async (monorepoRootPath) => {
+  const existPnpmWorkspaceFile = await fse.pathExists(
+    path2.join(monorepoRootPath, PNPM_WORKSPACE_FILE)
+  );
+  return existPnpmWorkspaceFile;
+};
+var isRushMonorepo = async (monorepoRootPath) => {
+  const existRushJsonFile = await fse.pathExists(
+    path2.join(monorepoRootPath, RUSH_JSON_FILE)
+  );
+  return existRushJsonFile;
+};
+var isMonorepo = async (monorepoRootPath, otherMonorepoChecks) => {
+  if (typeof otherMonorepoChecks === "object") {
+    for (const [monorepoType, monorepoCheck] of Object.entries(
+      otherMonorepoChecks
+    )) {
+      if (typeof monorepoCheck === "function" && await monorepoCheck(monorepoRootPath)) {
+        return {
+          isMonorepo: true,
+          type: monorepoType
+        };
+      }
+    }
+  }
+  if (await isPnpmMonorepo(monorepoRootPath)) {
+    return {
+      isMonorepo: true,
+      type: "pnpm"
+    };
+  }
+  if (await isRushMonorepo(monorepoRootPath)) {
+    return {
+      isMonorepo: true,
+      type: "rush"
+    };
+  }
+  return {
+    isMonorepo: false,
+    type: ""
+  };
+};
+
+// src/common/getBaseData.ts
+var 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 === path3.dirname(findPath)) {
+      break;
+    }
+    findPath = path3.dirname(findPath);
+  }
+  return {
+    isMonorepo: repoIsMonorepo,
+    rootPath: repoIsMonorepo ? findPath : "",
+    type,
+    getProjects: otherMonorepoAnalyzer?.[type]?.getProjects
+  };
+};
+
+// src/common/getProjects.ts
+init_esm();
+var getMonorepoSubProjects = async (monorepoBaseData) => {
+  const { type, rootPath, getProjects: getProjects3 } = monorepoBaseData;
+  if (type === "pnpm") {
+    const { getProjects: getPnpmMonorepoSubProjects } = await Promise.resolve().then(() => (init_pnpm(), pnpm_exports));
+    return getPnpmMonorepoSubProjects(rootPath);
+  }
+  if (type === "rush") {
+    const { getProjects: getRushMonorepoSubProjects } = await Promise.resolve().then(() => (init_rush(), rush_exports));
+    return getRushMonorepoSubProjects(rootPath);
+  }
+  if (getProjects3) {
+    return getProjects3(rootPath);
+  }
+  return [];
+};
+
+// src/common/index.ts
+init_pnpm();
+init_rush();
+
+// src/project-utils/getDependentProjects.ts
+init_utils();
+
+// src/project-utils/filter.ts
+init_esm();
+function hasExportsSourceField(exportsConfig, sourceField) {
+  return Object.values(exportsConfig).some(
+    (moduleRules) => typeof moduleRules === "object" && typeof moduleRules[sourceField] === "string"
+  );
+}
+var defaultFilter = (projects) => projects;
+var filterByField = (fieldName, checkExports) => (projects) => {
+  return projects.filter((p) => {
+    return fieldName in p.metaData || checkExports && hasExportsSourceField(p.metaData.exports || {}, fieldName);
+  });
+};
+
+// src/project-utils/getDependentProjects.ts
+var filterProjects = async (projects, filter) => {
+  if (!filter) {
+    return defaultFilter(projects);
+  }
+  return filter(projects);
+};
+var getDependentProjects = async (projectNameOrRootPath, options) => {
+  const {
+    cwd = process.cwd(),
+    recursive,
+    filter,
+    extraMonorepoStrategies
+  } = options;
+  const currentProjectPkgJsonPath = path8.join(
+    projectNameOrRootPath,
+    "package.json"
+  );
+  let projectName;
+  if (await fse4.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
+  });
+  dependentProjects = await filterProjects(dependentProjects, filter);
+  return dependentProjects;
+};
+
+// src/plugin.ts
 var PLUGIN_SOURCE_BUILD_NAME = "rsbuild:source-build";
 var getSourceInclude = async (options) => {
   const { projects, sourceField } = options;
@@ -67,11 +568,11 @@ function pluginSourceBuild(options) {
         }
       });
       const getReferences = async () => {
-        const refers = projects.map((project) => path2.join(project.dir, TS_CONFIG_FILE)).filter((filePath) => fs.existsSync(filePath));
+        const refers = projects.map((project) => path9.join(project.dir, TS_CONFIG_FILE)).filter((filePath) => fs2.existsSync(filePath));
         if (api.context.tsconfigPath) {
-          const { default: json5 } = await import("@rsbuild/shared/json5");
-          const { references } = json5.parse(
-            fse.readFileSync(api.context.tsconfigPath, "utf-8")
+          const { default: json52 } = await import("@rsbuild/shared/json5");
+          const { references } = json52.parse(
+            fse5.readFileSync(api.context.tsconfigPath, "utf-8")
           );
           return Array.isArray(references) ? references.map((r) => r.path).filter(Boolean).concat(refers) : refers;
         }
@@ -107,8 +608,14 @@ function pluginSourceBuild(options) {
     }
   };
 }
+
+// src/project/index.ts
+init_esm();
+init_project();
 export {
   PLUGIN_SOURCE_BUILD_NAME,
-  getSourceInclude,
+  Project,
+  getMonorepoBaseData,
+  getMonorepoSubProjects,
   pluginSourceBuild
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/plugin-source-build",
-  "version": "0.7.0-beta.2",
+  "version": "0.7.0-beta.4",
   "description": "Source build plugin of Rsbuild",
   "homepage": "https://rsbuild.dev",
   "repository": {
@@ -23,18 +23,18 @@
     "dist"
   ],
   "dependencies": {
-    "@rsbuild/monorepo-utils": "0.7.0-beta.2",
-    "@rsbuild/shared": "0.7.0-beta.2"
+    "fast-glob": "^3.3.2",
+    "@rsbuild/shared": "0.7.0-beta.4"
   },
   "devDependencies": {
     "@babel/core": "^7.24.5",
     "typescript": "^5.4.2",
-    "@rsbuild/core": "0.7.0-beta.2",
-    "@rsbuild/plugin-babel": "0.7.0-beta.2",
-    "@scripts/test-helper": "0.7.0-beta.2"
+    "@rsbuild/core": "0.7.0-beta.4",
+    "@rsbuild/plugin-babel": "0.7.0-beta.4",
+    "@scripts/test-helper": "0.7.0-beta.4"
   },
   "peerDependencies": {
-    "@rsbuild/core": "^0.7.0-beta.2"
+    "@rsbuild/core": "^0.7.0-beta.4"
   },
   "publishConfig": {
     "access": "public",