@modern-js/monorepo-tools 2.4.1-beta.0 → 2.6.0

package/dist/{js/node → cjs}/dag/create.js

@@ -1,21 +1,7 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -38,12 +24,19 @@ const initProjectDependencyAndDependent = (project, projectsName, projectsMap) =
   const dependencies = project.extra.dependencies || {};
   const devDependencies = project.extra.devDependencies || {};
   const optionalDependencies = project.extra.optionalDependencies || {};
-  const DependencyProjectsName = Object.keys(__spreadValues(__spreadValues(__spreadValues({}, dependencies), devDependencies), optionalDependencies)).filter((depName) => projectsName.includes(depName));
+  const DependencyProjectsName = Object.keys({
+    ...dependencies,
+    ...devDependencies,
+    ...optionalDependencies
+  }).filter((depName) => projectsName.includes(depName));
   project.dependent = project.dependent || [];
   project.dependency = DependencyProjectsName.map((projectName) => {
     const dependencyProject = projectsMap.get(projectName);
     const dependent = (dependencyProject == null ? void 0 : dependencyProject.dependent) || [];
-    if (!dependent.some((p) => p.name === project.name)) {
+    if (
+      // 消除重复添加的情况
+      !dependent.some((p) => p.name === project.name)
+    ) {
       dependencyProject.dependent = [...dependent, project];
       dependencyProject.dependentEdge = dependencyProject.dependent.length;
     }

package/dist/cjs/dag/operator.js

@@ -0,0 +1,269 @@
+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 __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);
+var operator_exports = {};
+__export(operator_exports, {
+  DagOperator: () => DagOperator
+});
+module.exports = __toCommonJS(operator_exports);
+var import_p_map = __toESM(require("p-map"));
+var import_error = require("../log/error");
+var import_task = require("./task");
+var import_edge_manager = require("./edge-manager");
+var import_utils = require("./utils");
+class DagOperator {
+  constructor(projects, projectsMap) {
+    this._createTask = (project, task) => async (stopTask = () => void 0) => {
+      await task(project, project.dependency || [], () => stopTask());
+      return project.name;
+    };
+    this._projects = projects;
+    this._projectsMap = projectsMap;
+    this._sortedProjects = [];
+  }
+  checkNodeDataExist(name) {
+    return this._projectsMap.has(name);
+  }
+  getNodeData(name, option = { checkExist: false }) {
+    if (option.checkExist) {
+      if (this._projectsMap.has(name)) {
+        return this._projectsMap.get(name);
+      } else {
+        (0, import_error.errorLog)(`No '${name}' project exist`);
+      }
+    }
+    return this._projectsMap.get(name);
+  }
+  getNodeDependencyData(name) {
+    var _a;
+    return ((_a = this._projectsMap.get(name)) == null ? void 0 : _a.dependency) || [];
+  }
+  getNodeDependentData(name) {
+    var _a;
+    return ((_a = this._projectsMap.get(name)) == null ? void 0 : _a.dependent) || [];
+  }
+  getNodeAllDependencyData(name, option = { skipCircleCheck: false }) {
+    const { skipCircleCheck } = option;
+    if (!skipCircleCheck) {
+      this.checkCircle();
+    }
+    if (!this._projectsMap.has(name)) {
+      (0, import_error.errorLog)(`No '${name}' project exist`);
+    }
+    const currentNode = this._projectsMap.get(name);
+    return (0, import_utils.recursiveGetDependency)(currentNode, skipCircleCheck);
+  }
+  setNodeData(name, task) {
+    if (this._projectsMap.has(name)) {
+      task(this._projectsMap.get(name));
+    } else {
+      (0, import_error.errorLog)(`No '${name}' project exist`);
+    }
+  }
+  async traverseAllNodes(task) {
+    const sortedNodes = this._sortedProjects.length > 0 ? this._sortedProjects : (0, import_utils.sortProjects)(this._projects);
+    const finishTaskHash = {};
+    let preNodes = [];
+    let earlyFinish = false;
+    for (const projects of sortedNodes) {
+      if (earlyFinish) {
+        break;
+      }
+      await (0, import_p_map.default)(
+        projects,
+        // eslint-disable-next-line @typescript-eslint/no-loop-func
+        async (project) => {
+          if (!finishTaskHash[project.name]) {
+            finishTaskHash[project.name] = true;
+            await task(
+              project,
+              this._getProjectPreviousNode(project.dependent || [], preNodes),
+              () => earlyFinish = true
+            );
+          }
+        },
+        { concurrency: projects.length }
+      );
+      preNodes = [...projects];
+    }
+  }
+  checkCircle() {
+    this._checkForCyclicDependencies(this._projects, [], /* @__PURE__ */ new Set());
+  }
+  async traverseDependenciesToProjectToDependent(name, task, config = {}) {
+    await this.traverseDependenciesToProject(name, task, config);
+    await this.traverseProjectToDependent(name, task, {
+      ...config,
+      withSelf: false
+    });
+  }
+  /**
+   * 1. 把目标节点当做叶子节点集合 A 中的元素
+   * 2. 当叶子节点集合中某个 a 元素结束任务的时候进行如下操作：
+   * 2.1 剪(去额外的)枝：获取 a 元素的 dependent集合，将该集合中元素的依赖列表进行过滤，过滤条件为：排除 a 以及 a 元素的 dependent集合以外的元素。
+   * 2.2 入度减一：对 a 元素的 dependent 集合元素的 dependencyEdge 减一
+   * 3. 检查是否存在 dependencyEdge === 0 的节点，加入叶子节点集合 A中。
+   * 4. 根据情况（是否存在空闲的进程）选择是否执行新加入的节点对应的任务。
+   */
+  async traverseProjectToDependent(name, task, { withSelf = false, runTaskConcurrency } = {}) {
+    if (!this._projectsMap.has(name)) {
+      (0, import_error.errorLog)(`No '${name}' project exist`);
+    }
+    const traverseTargetNode = this._projectsMap.get(name);
+    const leafNodeTasks = [
+      withSelf ? this._createTask(traverseTargetNode, task) : async () => Promise.resolve(traverseTargetNode.name)
+    ];
+    const taskRunner = new import_task.TaskRunner(leafNodeTasks, {
+      concurrency: runTaskConcurrency
+    });
+    const edgeManager = new import_edge_manager.EdgeManager();
+    taskRunner.on(import_task.TaskRunner.TASK_FINISH, (projectName) => {
+      const projectNode = this.getNodeData(projectName);
+      const dependent = projectNode.dependent || [];
+      for (const dependentProject of dependent) {
+        const dependency = dependentProject.dependency || [];
+        const removeNodes = dependency.filter(
+          (dependencyProject) => ![projectName, ...dependent.map((p) => p.name)].includes(
+            dependencyProject.name
+          )
+        );
+        edgeManager.reduceEdges(dependentProject, removeNodes.length + 1);
+        if (edgeManager.getEdge(dependentProject) === 0) {
+          taskRunner.addTask(this._createTask(dependentProject, task));
+        }
+      }
+    });
+    await taskRunner.run();
+  }
+  /**
+   * 1. 找到叶子节点集合 A
+   * 2. 找到直接连接叶子节点的节点集合 B
+   * 3. 当有某个叶子节点结束任务，则对该节点的直接连接的节点（或者理解成dependent）的枝数（或者叫入度）减一。
+   * 4. 检查 B 集合中是否存在入度为0的节点，则此节点为叶子节点，并加入叶子节点集合 A
+   * 5. 根据情况（是否存在空闲的进程）选择是否执行新加入的节点对应的任务。
+   */
+  // TODO: 执行顺序还需要再确定一下
+  async traverseDependenciesToProject(name, task, { withSelf = false, runTaskConcurrency } = {}) {
+    if (!this._projectsMap.has(name)) {
+      (0, import_error.errorLog)(`No '${name}' project exist`);
+    }
+    const traverseTargetNode = this._projectsMap.get(name);
+    const leafNodes = this._getDependencyLeafNodes(traverseTargetNode);
+    if ((leafNodes == null ? void 0 : leafNodes.length) === 0) {
+      await this._createTask(traverseTargetNode, task)();
+      return;
+    }
+    const leafNodeTasks = leafNodes.map(
+      (project) => this._createTask(project, task)
+    );
+    const taskRunner = new import_task.TaskRunner(leafNodeTasks, {
+      concurrency: runTaskConcurrency
+    });
+    const edgeManager = new import_edge_manager.EdgeManager();
+    taskRunner.on(import_task.TaskRunner.TASK_FINISH, (projectName) => {
+      const projectNode = this.getNodeData(projectName);
+      const dependent = projectNode.dependent || [];
+      for (const dependentProject of dependent) {
+        if (![traverseTargetNode, ...leafNodes].some(
+          (n) => n.name === dependentProject.name
+        )) {
+          continue;
+        }
+        edgeManager.reduceOneEdge(dependentProject);
+        if (dependentProject.name === traverseTargetNode.name && !withSelf) {
+          continue;
+        }
+        if (edgeManager.getEdge(dependentProject) === 0) {
+          taskRunner.addTask(this._createTask(dependentProject, task));
+        }
+      }
+    });
+    await taskRunner.run();
+  }
+  /**
+   * Copyright (c) Microsoft Corporation. All rights reserved.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file at
+   * https://github.com/microsoft/rushstack/blob/master/apps/rush-lib/LICENSE
+   *
+  /**
+   * Checks for projects that indirectly depend on themselves.
+   */
+  _checkForCyclicDependencies(projects, dependencyChain, alreadyCheckedProjects) {
+    for (const project of projects) {
+      if (dependencyChain.includes(project.name)) {
+        throw new Error(
+          `${"A cyclic dependency was encountered:\n"}    ${[
+            ...dependencyChain,
+            project.name
+          ].reverse().join("\n  -> ")}
+`
+        );
+      }
+      if (!alreadyCheckedProjects.has(project.name)) {
+        alreadyCheckedProjects.add(project.name);
+        dependencyChain.push(project.name);
+        this._checkForCyclicDependencies(
+          project.dependent,
+          dependencyChain,
+          alreadyCheckedProjects
+        );
+        dependencyChain.pop();
+      }
+    }
+  }
+  _getDependencyLeafNodes(node) {
+    const dependency = node.dependency;
+    if (dependency.length === 0) {
+      return [];
+    }
+    let leafNodes = [...dependency];
+    for (const dependencyNode of dependency) {
+      leafNodes = [
+        ...leafNodes,
+        ...this._getDependencyLeafNodes(dependencyNode)
+      ];
+    }
+    return leafNodes;
+  }
+  _getProjectPreviousNode(searchProjects, preNodes) {
+    return searchProjects.filter(
+      (p) => preNodes.map((preP) => preP.name).includes(p.name)
+    );
+  }
+  // public async getOrderTasks() {
+  //     // Precalculate the number of dependent packages
+  //   for (const project of this._projects) {
+  //     calculateCriticalPaths(project);
+  //   }
+  // }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DagOperator
+});

package/dist/{js/node → cjs}/dag/task.js

@@ -17,30 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 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);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 var task_exports = {};
 __export(task_exports, {
   TaskRunner: () => TaskRunner
@@ -56,44 +40,40 @@ const _TaskRunner = class extends import_events.EventEmitter {
     this._usableConcurrency = this._concurrency;
     this._stopFlag = false;
   }
-  run() {
-    return __async(this, null, function* () {
-      const tasks = this._tasks.splice(0, this._concurrency);
-      this._usableConcurrency = this._concurrency - tasks.length;
-      yield (0, import_p_map.default)(
-        tasks,
-        (task) => __async(this, null, function* () {
-          yield this._runTask(task);
-        }),
-        { concurrency: tasks.length }
-      );
-    });
+  async run() {
+    const tasks = this._tasks.splice(0, this._concurrency);
+    this._usableConcurrency = this._concurrency - tasks.length;
+    await (0, import_p_map.default)(
+      tasks,
+      async (task) => {
+        await this._runTask(task);
+      },
+      { concurrency: tasks.length }
+    );
   }
   addTask(task) {
     this._tasks.push(task);
   }
-  _runTask(task) {
-    return __async(this, null, function* () {
-      if (this._stopFlag) {
-        return;
-      }
-      const emitValue = yield task(this._stopTask.bind(this));
-      this._usableConcurrency--;
-      this.emit(_TaskRunner.TASK_FINISH, emitValue);
-      if (this._tasks.length > 0) {
-        const nextTasks = this._tasks.splice(0, this._usableConcurrency);
-        this._usableConcurrency -= nextTasks.length;
-        if (nextTasks.length > 0) {
-          yield (0, import_p_map.default)(
-            nextTasks,
-            (_task) => __async(this, null, function* () {
-              yield this._runTask(_task);
-            }),
-            { concurrency: nextTasks.length }
-          );
-        }
+  async _runTask(task) {
+    if (this._stopFlag) {
+      return;
+    }
+    const emitValue = await task(this._stopTask.bind(this));
+    this._usableConcurrency--;
+    this.emit(_TaskRunner.TASK_FINISH, emitValue);
+    if (this._tasks.length > 0) {
+      const nextTasks = this._tasks.splice(0, this._usableConcurrency);
+      this._usableConcurrency -= nextTasks.length;
+      if (nextTasks.length > 0) {
+        await (0, import_p_map.default)(
+          nextTasks,
+          async (_task) => {
+            await this._runTask(_task);
+          },
+          { concurrency: nextTasks.length }
+        );
       }
-    });
+    }
   }
   _stopTask() {
     this._stopFlag = true;

package/dist/{js/node → cjs}/features/build/index.js

@@ -17,30 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 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);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 var build_exports = {};
 __export(build_exports, {
   runAllBuildTask: () => runAllBuildTask,
@@ -59,17 +43,17 @@ const createTask = (config, taskCmds = defaultBuildCmds, taskLogger) => {
     disableContentHash = false,
     enableGitHash = false
   } = config;
-  const task = (project) => __async(void 0, null, function* () {
+  const task = async (project) => {
     console.info("run ", project.name);
     if (!disableContentHash) {
-      const changed = yield (0, import_check_project_change.checkProjectChangeByContent)(project);
+      const changed = await (0, import_check_project_change.checkProjectChangeByContent)(project);
       if (!changed) {
         console.info(`${project.name} content not change, skip`);
         return;
       }
     }
     if (enableGitHash) {
-      const changed = yield (0, import_check_project_change.checkProjectChangeByGit)(project, rootPath);
+      const changed = await (0, import_check_project_change.checkProjectChangeByGit)(project, rootPath);
       if (!changed) {
         console.info(`${project.name} not change, skip`);
         return;
@@ -91,7 +75,7 @@ const createTask = (config, taskCmds = defaultBuildCmds, taskLogger) => {
             stderr: childProcess.stderr,
             logConfig: { label: "BUILD: " }
           });
-          yield childProcess;
+          await childProcess;
           import_utils.signale.timeEnd(prefix);
         } catch (e) {
           (0, import_error.errorLog)(project.name, e.message);
@@ -100,11 +84,11 @@ const createTask = (config, taskCmds = defaultBuildCmds, taskLogger) => {
         console.info(`${project.name} not have ${taskCmd}, skip it.`);
       }
     }
-  });
+  };
   return task;
 };
 const defaultBuildCmds = ["build"];
-const runBuildTask = (_0, _1, _2, ..._3) => __async(void 0, [_0, _1, _2, ..._3], function* (projectName, operator, config, taskCmds = defaultBuildCmds) {
+const runBuildTask = async (projectName, operator, config, taskCmds = defaultBuildCmds) => {
   const {
     withSelf = true,
     onlySelf = false,
@@ -114,14 +98,14 @@ const runBuildTask = (_0, _1, _2, ..._3) => __async(void 0, [_0, _1, _2, ..._3],
   const taskLogger = new import_multi_tasks_log.MultitasksLogger();
   const task = createTask(config, taskCmds, taskLogger);
   if (onlySelf) {
-    yield task(operator.getNodeData(projectName, { checkExist: true }));
+    await task(operator.getNodeData(projectName, { checkExist: true }));
   } else if (!disableWithDeps && withDept) {
-    yield operator.traverseDependenciesToProjectToDependent(projectName, task, {
+    await operator.traverseDependenciesToProjectToDependent(projectName, task, {
       withSelf,
       runTaskConcurrency: import_os.default.cpus().length
     });
   } else if (disableWithDeps && withDept) {
-    yield operator.traverseProjectToDependent(projectName, task, {
+    await operator.traverseProjectToDependent(projectName, task, {
       withSelf,
       runTaskConcurrency: import_os.default.cpus().length
     });
@@ -131,12 +115,12 @@ const runBuildTask = (_0, _1, _2, ..._3) => __async(void 0, [_0, _1, _2, ..._3],
       runTaskConcurrency: import_os.default.cpus().length
     });
   }
-});
-const runAllBuildTask = (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (operator, config, taskCmds = defaultBuildCmds) {
+};
+const runAllBuildTask = async (operator, config, taskCmds = defaultBuildCmds) => {
   const taskLogger = new import_multi_tasks_log.MultitasksLogger();
   const task = createTask(config, taskCmds, taskLogger);
-  yield operator.traverseAllNodes(task);
-});
+  await operator.traverseAllNodes(task);
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   runAllBuildTask,

package/dist/{js/node → cjs}/features/clear/index.js

@@ -17,6 +17,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 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
 ));

package/dist/{js/node → cjs}/features/deploy/index.js

@@ -17,30 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 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);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 var deploy_exports = {};
 __export(deploy_exports, {
   deploy: () => deploy
@@ -103,7 +87,7 @@ const generatorAndCopyRequiredFiles = (rootPath, deployDir) => {
   copy("package-lock.json");
   checkAndUpdatePMWorkspaces(deployDir);
 };
-const checkAndRunDeployCommand = (monorepoPath, targetProject, packageManager) => __async(void 0, null, function* () {
+const checkAndRunDeployCommand = async (monorepoPath, targetProject, packageManager) => {
   var _a, _b, _c;
   const scripts = ((_a = targetProject.extra) == null ? void 0 : _a.scripts) || {};
   if (scripts.deploy) {
@@ -112,7 +96,7 @@ const checkAndRunDeployCommand = (monorepoPath, targetProject, packageManager) =
     );
     let runDeployCommands = ["run", "deploy"];
     if (packageManager === "pnpm") {
-      const pnpmVersion = yield (0, import_utils.getPnpmVersion)();
+      const pnpmVersion = await (0, import_utils.getPnpmVersion)();
       if (pnpmVersion.startsWith("6")) {
         runDeployCommands = ["run", "deploy", "--filter", targetProject.name];
       } else {
@@ -128,10 +112,10 @@ const checkAndRunDeployCommand = (monorepoPath, targetProject, packageManager) =
     });
     (_b = childProcess.stdout) == null ? void 0 : _b.pipe(process.stdout);
     (_c = childProcess.stderr) == null ? void 0 : _c.pipe(process.stderr);
-    yield childProcess;
+    await childProcess;
   }
-});
-const installDependency = (deployDir, packageManager) => __async(void 0, null, function* () {
+};
+const installDependency = async (deployDir, packageManager) => {
   const packageJsonPath = path.join(deployDir, "package.json");
   const packageJson = import_node_core_library.JsonFile.load(packageJsonPath);
   const scripts = (packageJson == null ? void 0 : packageJson.scripts) || {};
@@ -153,11 +137,11 @@ const installDependency = (deployDir, packageManager) => __async(void 0, null, f
     cwd: deployDir,
     env: { NODE_ENV: void 0 }
   });
-  yield childProcess;
-});
+  await childProcess;
+};
 const excludeDirs = (filePath, dirs) => dirs.some((dir) => filePath.includes(dir));
 const defaultDeployPath = "output";
-const deploy = (deployProjectNames, operator, config) => __async(void 0, null, function* () {
+const deploy = async (deployProjectNames, operator, config) => {
   const { rootPath, packageManager, deployPath = defaultDeployPath } = config;
   const realDeployPath = path.isAbsolute(deployPath) ? deployPath : path.join(rootPath, deployPath);
   import_node_core_library.FileSystem.deleteFolder(realDeployPath);
@@ -172,12 +156,13 @@ const deploy = (deployProjectNames, operator, config) => __async(void 0, null, f
       alldeps,
       realDeployPath
     );
-    yield checkAndRunDeployCommand(rootPath, currentProject, packageManager);
+    await checkAndRunDeployCommand(rootPath, currentProject, packageManager);
     import_node_core_library.FileSystem.ensureFolder(realDeployPath);
     for (const [from, to] of copyMap) {
       import_node_core_library.FileSystem.copyFiles({
         sourcePath: from,
         destinationPath: to,
+        // If true, then when copying symlinks, copy the target object instead of copying the link.
         dereferenceSymlinks: false,
         filter(filePath) {
           if (excludeDirs(filePath, ["node_modules", "dist"])) {
@@ -190,7 +175,7 @@ const deploy = (deployProjectNames, operator, config) => __async(void 0, null, f
   }
   generatorAndCopyRequiredFiles(rootPath, realDeployPath);
   import_utils.logger.success(`Deploy success. The deploy dir is in '${rootPath}/output'`);
-});
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   deploy