@rsbuild/plugin-source-build 1.0.1 → 1.0.2

package/dist/index.cjs

@@ -1,567 +1,487 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+var __webpack_modules__ = {
+    yaml: function(module) {
+        module.exports = import("yaml");
+    }
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  PLUGIN_SOURCE_BUILD_NAME: () => PLUGIN_SOURCE_BUILD_NAME,
-  Project: () => Project,
-  getMonorepoBaseData: () => getMonorepoBaseData,
-  getMonorepoSubProjects: () => getMonorepoSubProjects,
-  pluginSourceBuild: () => pluginSourceBuild
+/************************************************************************/ // The module cache
+var __webpack_module_cache__ = {};
+// The require function
+function __webpack_require__(moduleId) {
+    // Check if module is in cache
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    // Create a new module (and put it into the cache)
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    // Execute the module function
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    // Return the exports of the module
+    return module.exports;
+}
+/************************************************************************/ // webpack/runtime/compat_get_default_export
+(()=>{
+    // getDefaultExport function for compatibility with non-ESM modules
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+// webpack/runtime/define_property_getters
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+// webpack/runtime/has_own_property
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+// webpack/runtime/make_namespace_object
+(()=>{
+    // define __esModule on exports
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+/************************************************************************/ var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+    getMonorepoBaseData: ()=>/* reexport */ getMonorepoBaseData,
+    PLUGIN_SOURCE_BUILD_NAME: ()=>/* reexport */ PLUGIN_SOURCE_BUILD_NAME,
+    pluginSourceBuild: ()=>/* reexport */ pluginSourceBuild,
+    getMonorepoSubProjects: ()=>/* reexport */ getMonorepoSubProjects,
+    Project: ()=>/* reexport */ Project
 });
-module.exports = __toCommonJS(src_exports);
-
-// src/plugin.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
-var import_json52 = __toESM(require("json5"), 1);
-
-// src/project-utils/getDependentProjects.ts
-var import_node_fs5 = __toESM(require("fs"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
-
-// src/common/getBaseData.ts
-var import_node_path2 = __toESM(require("path"), 1);
-
-// src/common/isMonorepo.ts
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
-
-// src/constants.ts
-var PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
-var RUSH_JSON_FILE = "rush.json";
-var PACKAGE_JSON = "package.json";
-
-// src/common/isMonorepo.ts
-async function pathExists(path9) {
-  return import_node_fs.default.promises.access(path9).then(() => true).catch(() => false);
+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);
 }
-var isPnpmMonorepo = async (monorepoRootPath) => {
-  const existPnpmWorkspaceFile = await pathExists(
-    import_node_path.default.join(monorepoRootPath, PNPM_WORKSPACE_FILE)
-  );
-  return existPnpmWorkspaceFile;
+const isPnpmMonorepo = async (monorepoRootPath)=>{
+    const existPnpmWorkspaceFile = await pathExists(external_node_path_default().join(monorepoRootPath, PNPM_WORKSPACE_FILE));
+    return existPnpmWorkspaceFile;
 };
-var isRushMonorepo = async (monorepoRootPath) => {
-  const existRushJsonFile = await pathExists(
-    import_node_path.default.join(monorepoRootPath, RUSH_JSON_FILE)
-  );
-  return existRushJsonFile;
+const isRushMonorepo = async (monorepoRootPath)=>{
+    const existRushJsonFile = await pathExists(external_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
+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 isPnpmMonorepo(monorepoRootPath)) return {
+        isMonorepo: true,
+        type: 'pnpm'
+    };
+    if (await isRushMonorepo(monorepoRootPath)) return {
+        isMonorepo: true,
+        type: 'rush'
     };
-  }
-  if (await isRushMonorepo(monorepoRootPath)) {
     return {
-      isMonorepo: true,
-      type: "rush"
+        isMonorepo: false,
+        type: ''
     };
-  }
-  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;
+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 === import_node_path2.default.dirname(findPath)) {
-      break;
+    while(true){
+        const result = await isMonorepo(findPath, otherMonorepoChecks);
+        if (result.isMonorepo) {
+            repoIsMonorepo = true;
+            ({ type } = result);
+            break;
+        }
+        // find system root path
+        if (findPath === external_node_path_default().dirname(findPath)) break;
+        findPath = external_node_path_default().dirname(findPath);
     }
-    findPath = import_node_path2.default.dirname(findPath);
-  }
-  return {
-    isMonorepo: repoIsMonorepo,
-    rootPath: repoIsMonorepo ? findPath : "",
-    type,
-    getProjects: otherMonorepoAnalyzer?.[type]?.getProjects
-  };
-};
-
-// src/common/pnpm.ts
-var import_node_fs4 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-
-// src/project.ts
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-
-// src/utils.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-var import_json5 = __toESM(require("json5"), 1);
-var readPackageJson = async (pkgJsonFilePath) => {
-  return readJson(pkgJsonFilePath);
+    return {
+        isMonorepo: repoIsMonorepo,
+        rootPath: repoIsMonorepo ? findPath : '',
+        type,
+        getProjects: null == otherMonorepoAnalyzer ? void 0 : null === (_otherMonorepoAnalyzer_type = otherMonorepoAnalyzer[type]) || void 0 === _otherMonorepoAnalyzer_type ? void 0 : _otherMonorepoAnalyzer_type.getProjects
+    };
 };
-var readRushJson = async (rushJsonFilePath) => {
-  const rushJson = readJson(
-    rushJsonFilePath.includes(RUSH_JSON_FILE) ? rushJsonFilePath : import_node_path3.default.join(rushJsonFilePath, RUSH_JSON_FILE)
-  );
-  return rushJson;
+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 pathExists2(path9) {
-  return import_node_fs2.default.promises.access(path9).then(() => true).catch(() => false);
+async function utils_pathExists(path) {
+    return external_node_fs_default().promises.access(path).then(()=>true).catch(()=>false);
 }
-var readJson = async (jsonFileAbsPath) => {
-  if (!await pathExists2(jsonFileAbsPath)) {
-    return {};
-  }
-  const content = await import_node_fs2.default.promises.readFile(jsonFileAbsPath, "utf-8");
-  const json = import_json5.default.parse(content);
-  return json;
+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;
 };
-
-// src/project.ts
-var Project = class {
-  constructor(name, dir) {
-    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);
+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(), /**
+   *
+   * @param paths normalize paths
+   * @returns common root paths
+   */ _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));
     }
-    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);
-      }
+    getMetaData() {
+        if (null === this.metaData) throw new Error('The Project object needs to be initialized by executing the `init` function');
+        return this.metaData;
     }
-    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));
-      }
+    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;
     }
-    for (const d of Object.keys(devDependencies)) {
-      if (allProjectMap.has(d)) {
-        projects.push(allProjectMap.get(d));
-      }
+    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;
     }
-    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 = this.#getExportsSourceDirs(
-        pkgJson.exports ?? {},
-        sourceField
-      );
-      sourceDirs.push(...exportsSourceDirs);
+    getSourceEntryPaths(options) {
+        const { exports: checkExports = false, field: sourceField = 'source' } = options ?? {};
+        const pkgJson = this.getMetaData();
+        // normalize strings
+        const sourceDirs = pkgJson[sourceField] ? [
+            external_node_path_default().normalize(pkgJson[sourceField])
+        ] : [];
+        if (checkExports) {
+            /**
+       * analyze exports:
+       * "exports": {
+       *   ".": {
+       *     "source": "./src/index.ts"
+       *   }
+       * },
+       */ 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);
     }
-    if (!sourceDirs.length) {
-      throw new Error(
-        `"${sourceField}" field is not found in ${this.name} package.json`
-      );
+    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;
     }
-    return this.#getCommonRootPaths(sourceDirs);
-  }
-  #getExportsSourceDirs(exportsConfig, sourceField) {
+}
+function getExportsSourceDirs(exportsConfig, sourceField) {
     const exportsSourceDirs = [];
-    if (typeof exportsConfig[sourceField] === "string") {
-      exportsSourceDirs.push(
-        import_node_path4.default.normalize(exportsConfig[sourceField])
-      );
-    }
-    for (const moduleRules of Object.values(exportsConfig)) {
-      if (typeof moduleRules === "object" && typeof moduleRules[sourceField] === "string") {
-        exportsSourceDirs.push(
-          import_node_path4.default.normalize(moduleRules[sourceField])
-        );
-      }
-    }
+    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]));
+    // normalize strings
     return exportsSourceDirs;
-  }
-  /**
-   *
-   * @param paths normalize paths
-   * @returns common root paths
-   */
-  #getCommonRootPaths(paths) {
-    const commonRootPathsSet = /* @__PURE__ */ new Set();
-    for (const p of paths) {
-      let dir;
-      try {
-        dir = import_node_fs3.default.statSync(p).isDirectory() ? p : import_node_path4.default.dirname(p);
-      } catch {
-        dir = import_node_path4.default.dirname(p);
-      }
-      const rootPath = this.#getRootPath(dir);
-      if (!commonRootPathsSet.has(rootPath)) {
-        commonRootPathsSet.add(rootPath);
-      }
+}
+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);
     }
-    return Array.from(commonRootPathsSet).map((p) => import_node_path4.default.join(this.dir, p));
-  }
-  #getRootPath(p) {
-    return p.split(import_node_path4.default.sep)[0];
-  }
-};
-
-// src/common/pnpm.ts
-var getPatternsFromYaml = async (monorepoRoot) => {
-  const { parse } = await import("yaml");
-  const workspaceYamlFilePath = import_node_path5.default.join(monorepoRoot, PNPM_WORKSPACE_FILE);
-  const yamlContent = await import_node_fs4.default.promises.readFile(workspaceYamlFilePath, "utf8");
-  const pnpmWorkspace = parse(yamlContent);
-  return pnpmWorkspace.packages || [];
+    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 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 || [];
 };
-var normalize = (results) => results.map((fp) => import_node_path5.default.normalize(fp));
-var 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/**"
+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 = [
+        // allow globs like "packages/**" or "packages/*",
+        // but avoid picking up node_modules/**/package.json and dist/**/package.json
+        '**/dist/**',
+        '**/node_modules/**'
     ];
-  }
-  return globOpts;
+    return globOpts;
 };
-var 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);
-  };
+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);
+        // fast-glob does not respect pattern order, so we re-sort by absolute path
+        result = result.sort();
+        // POSIX results always need to be normalized
+        result = normalize(result);
+        return fileMapper(result);
+    };
 };
-var 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 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 projects = await finder(PACKAGE_JSON, (filePaths)=>Promise.all(filePaths.map(mapper)));
+    return projects;
 };
-var 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 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;
+    }));
 };
-
-// src/common/rush.ts
-var import_node_path6 = __toESM(require("path"), 1);
-var 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;
-    })
-  );
+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;
+    }));
 };
-
-// src/common/getProjects.ts
-var getMonorepoSubProjects = async (monorepoBaseData) => {
-  const { type, rootPath, getProjects: getProjects3 } = monorepoBaseData;
-  if (type === "pnpm") {
-    return getProjects(rootPath);
-  }
-  if (type === "rush") {
-    return getProjects2(rootPath);
-  }
-  if (getProjects3) {
-    return getProjects3(rootPath);
-  }
-  return [];
+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 [];
 };
-
-// src/project-utils/getDependentProjects.ts
-async function pathExists3(path9) {
-  return import_node_fs5.default.promises.access(path9).then(() => true).catch(() => false);
+async function getDependentProjects_pathExists(path) {
+    return external_node_fs_default().promises.access(path).then(()=>true).catch(()=>false);
 }
-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 pathExists3(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;
+const getDependentProjects = async (projectNameOrRootPath, options)=>{
+    const { cwd = process.cwd(), recursive, filter, extraMonorepoStrategies } = options;
+    // check if first argument is projectRootPath.
+    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;
 };
-
-// src/project-utils/filter.ts
 function hasExportsSourceField(exportsConfig, sourceField) {
-  return typeof exportsConfig[sourceField] === "string" || Object.values(exportsConfig).some(
-    (moduleRules) => typeof moduleRules === "object" && typeof moduleRules[sourceField] === "string"
-  );
+    return 'string' == typeof exportsConfig[sourceField] || Object.values(exportsConfig).some((moduleRules)=>'object' == typeof moduleRules && 'string' == typeof moduleRules[sourceField]);
 }
-var filterByField = (fieldName, checkExports) => (projects) => {
-  return projects.filter((p) => {
-    return fieldName in p.metaData || checkExports && hasExportsSourceField(p.metaData.exports || {}, fieldName);
-  });
-};
-
-// src/plugin.ts
-var PLUGIN_SOURCE_BUILD_NAME = "rsbuild:source-build";
-var getSourceInclude = async (options) => {
-  const { projects, sourceField } = options;
-  const includes = [];
-  for (const project of projects) {
-    includes.push(
-      ...project.getSourceEntryPaths({ field: sourceField, exports: true })
-    );
-  }
-  return includes;
+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];
-      });
-      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(
-              resolvePriority === "source" ? [sourceField, "..."] : ["...", sourceField]
-            );
-            rule.resolve.conditionNames.add("...").add(sourceField);
-          }
-        }
-      });
-      const getReferences = async (tsconfigPath, rspackReferences) => {
-        const references = /* @__PURE__ */ new Set();
-        for (const project of projects || []) {
-          const filePath = import_node_path8.default.join(project.dir, "tsconfig.json");
-          if (import_node_fs6.default.existsSync(filePath)) {
-            references.add(filePath);
-          }
-        }
-        const tsconfig = import_json52.default.parse(
-          import_node_fs6.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 = import_node_path8.default.dirname(tsconfigPath);
-          for (const item of userReferences) {
-            if (!item) {
-              continue;
-            }
-            const absolutePath = import_node_path8.default.isAbsolute(item) ? item : import_node_path8.default.join(baseDir, item);
-            references.add(absolutePath);
-          }
+    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
+                ];
+            });
+            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);
+                    // https://rspack.dev/config/resolve
+                    // when source is not exist, other mainFields will effect. // source > Rspack default mainFields.
+                    rule.resolve.mainFields.merge('source' === resolvePriority ? [
+                        sourceField,
+                        '...'
+                    ] : [
+                        '...',
+                        sourceField
+                    ]);
+                    // `conditionNames` is not affected by `resolvePriority`.
+                    // The priority is controlled by the order of fields declared in `exports`.
+                    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);
+                }
+                // Add references in the current project's tsconfig.json
+                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);
+                    }
+                }
+                // avoid self reference, it will break the resolver
+                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: (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);
+                // set references config
+                // https://github.com/dividab/tsconfig-paths-webpack-plugin#options
+                chain.resolve.plugin(TS_CONFIG_PATHS).tap((options)=>options.map((option)=>({
+                            ...option,
+                            references
+                        })));
+            });
         }
-        references.delete(tsconfigPath);
-        return Array.from(references);
-      };
-      if (api.context.bundlerType === "rspack") {
-        api.modifyRspackConfig(async (config, { environment }) => {
-          const { tsconfigPath } = environment;
-          if (!tsconfigPath) {
-            return;
-          }
-          config.resolve ||= {};
-          const { tsConfig = { configFile: tsconfigPath } } = config.resolve;
-          const configObject = typeof tsConfig === "string" ? { configFile: tsConfig } : tsConfig;
-          const references = await getReferences(
-            tsconfigPath,
-            configObject.references
-          );
-          config.resolve.tsConfig = {
-            configFile: configObject?.configFile || tsconfigPath,
-            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(
-            (options2) => options2.map((option) => ({
-              ...option,
-              references
-            }))
-          );
-        });
-      }
-    }
-  };
+    };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PLUGIN_SOURCE_BUILD_NAME,
-  Project,
-  getMonorepoBaseData,
-  getMonorepoSubProjects,
-  pluginSourceBuild
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
 });