@modern-js/monorepo-tools 2.4.0 → 2.5.0

package/dist/cjs/dag/operator.js

@@ -0,0 +1,232 @@
+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(
+  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,
+        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
+    });
+  }
+  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();
+  }
+  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();
+  }
+  _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)
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DagOperator
+});

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

@@ -21,26 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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 +36,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

@@ -21,26 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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 +39,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 +71,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 +80,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 +94,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 +111,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/deploy/index.js

@@ -21,26 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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 +83,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 +92,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 +108,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 +133,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,7 +152,7 @@ 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({
@@ -190,7 +170,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

package/dist/{js/node → cjs}/features/dev/create-task.js

@@ -21,26 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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 create_task_exports = {};
 __export(create_task_exports, {
   createDependenciesTask: () => createDependenciesTask,
@@ -67,7 +47,7 @@ const getFinalTaskCmds = (taskCmds, project) => {
 const createDependenciesTask = (config, taskCmds = import_cmds.defaultBuildWatchCmds, taskLogger) => {
   const { packageManager } = config;
   const timelogInstance = timeLog.initTimeLog();
-  const task = (project) => __async(void 0, null, function* () {
+  const task = async (project) => {
     const finalTaskCmds = getFinalTaskCmds(taskCmds, project);
     const cmd = project.extra.scripts || {};
     for (const taskCmd of finalTaskCmds) {
@@ -84,7 +64,7 @@ const createDependenciesTask = (config, taskCmds = import_cmds.defaultBuildWatch
             stderr: childProcess.stderr,
             logConfig: { label: "WATCH: " }
           });
-          yield childProcess;
+          await childProcess;
         } catch (e) {
           (0, import_error.errorLog)(project.name, e);
         }
@@ -93,12 +73,12 @@ const createDependenciesTask = (config, taskCmds = import_cmds.defaultBuildWatch
         import_utils.logger.info(`${project.name} not have ${taskCmd}, skip it.`);
       }
     }
-  });
+  };
   return task;
 };
 const createDevTask = (config, taskCmds = import_cmds.defaultBuildWatchCmds, taskLogger) => {
   const { packageManager } = config;
-  const task = (project) => __async(void 0, null, function* () {
+  const task = async (project) => {
     const devCmds = [taskCmds[0]];
     const cmd = project.extra.scripts || {};
     for (const taskCmd of devCmds) {
@@ -114,7 +94,7 @@ const createDevTask = (config, taskCmds = import_cmds.defaultBuildWatchCmds, tas
             stderr: childProcess.stderr,
             logConfig: { label: `${taskCmd.toUpperCase()}: ` }
           });
-          const ret = yield childProcess;
+          const ret = await childProcess;
           console.info(ret);
         } catch (e) {
           (0, import_error.errorLog)(project.name, e);
@@ -123,7 +103,7 @@ const createDevTask = (config, taskCmds = import_cmds.defaultBuildWatchCmds, tas
         import_utils.logger.info(`${project.name} not have ${taskCmd}, skip it.`);
       }
     }
-  });
+  };
   return task;
 };
 // Annotate the CommonJS export names for ESM import in node: