@modern-js/monorepo-tools 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/js/node/dag/operator.js

@@ -1,27 +1,79 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 stdin_exports = {};
+__export(stdin_exports, {
+  DagOperator: () => DagOperator
 });
-exports.DagOperator = void 0;
-var _pMap = _interopRequireDefault(require("p-map"));
-var _error = require("../log/error");
-var _task = require("./task");
-var _edgeManager = require("./edge-manager");
-var _utils = require("./utils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(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; }
+module.exports = __toCommonJS(stdin_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");
+var __defProp2 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp2.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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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());
+  });
+};
 class DagOperator {
-  // 排序好的项目列表
-
   constructor(projects, projectsMap) {
-    _defineProperty(this, "_projects", void 0);
-    _defineProperty(this, "_projectsMap", void 0);
-    _defineProperty(this, "_sortedProjects", void 0);
-    _defineProperty(this, "_createTask", (project, task) => async (stopTask = () => undefined) => {
-      await task(project, project.dependency || [], () => stopTask());
+    this._createTask = (project, task) => (stopTask = () => void 0) => __async(this, null, function* () {
+      yield task(project, project.dependency || [], () => stopTask());
       return project.name;
     });
     this._projects = projects;
@@ -31,187 +83,173 @@ class DagOperator {
   checkNodeDataExist(name) {
     return this._projectsMap.has(name);
   }
-  getNodeData(name, option = {
-    checkExist: false
-  }) {
+  getNodeData(name, option = { checkExist: false }) {
     if (option.checkExist) {
       if (this._projectsMap.has(name)) {
         return this._projectsMap.get(name);
       } else {
-        (0, _error.errorLog)(`No '${name}' project exist`);
+        (0, import_error.errorLog)(`No '${name}' project exist`);
       }
     }
     return this._projectsMap.get(name);
   }
   getNodeDependencyData(name) {
-    var _this$_projectsMap$ge;
-    return ((_this$_projectsMap$ge = this._projectsMap.get(name)) === null || _this$_projectsMap$ge === void 0 ? void 0 : _this$_projectsMap$ge.dependency) || [];
+    var _a;
+    return ((_a = this._projectsMap.get(name)) == null ? void 0 : _a.dependency) || [];
   }
   getNodeDependentData(name) {
-    var _this$_projectsMap$ge2;
-    return ((_this$_projectsMap$ge2 = this._projectsMap.get(name)) === null || _this$_projectsMap$ge2 === void 0 ? void 0 : _this$_projectsMap$ge2.dependent) || [];
-  }
-  getNodeAllDependencyData(name, option = {
-    skipCircleCheck: false
-  }) {
-    const {
-      skipCircleCheck
-    } = option;
+    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, _error.errorLog)(`No '${name}' project exist`);
+      (0, import_error.errorLog)(`No '${name}' project exist`);
     }
     const currentNode = this._projectsMap.get(name);
-    return (0, _utils.recursiveGetDependency)(currentNode, skipCircleCheck);
+    return (0, import_utils.recursiveGetDependency)(currentNode, skipCircleCheck);
   }
   setNodeData(name, task) {
     if (this._projectsMap.has(name)) {
       task(this._projectsMap.get(name));
     } else {
-      (0, _error.errorLog)(`No '${name}' project exist`);
+      (0, import_error.errorLog)(`No '${name}' project exist`);
     }
   }
-  async traverseAllNodes(task) {
-    const sortedNodes = this._sortedProjects.length > 0 ? this._sortedProjects : (0, _utils.sortProjects)(this._projects);
-    const finishTaskHash = {};
-    let preNodes = [];
-    let earlyFinish = false;
-    for (const projects of sortedNodes) {
-      if (earlyFinish) {
-        break;
-      }
-      await (0, _pMap.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);
+  traverseAllNodes(task) {
+    return __async(this, null, function* () {
+      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;
         }
-      }, {
-        concurrency: projects.length
-      });
-      preNodes = [...projects];
-    }
+        yield (0, import_p_map.default)(
+          projects,
+          (project) => __async(this, null, function* () {
+            if (!finishTaskHash[project.name]) {
+              finishTaskHash[project.name] = true;
+              yield task(
+                project,
+                this._getProjectPreviousNode(project.dependent || [], preNodes),
+                () => earlyFinish = true
+              );
+            }
+          }),
+          { concurrency: projects.length }
+        );
+        preNodes = [...projects];
+      }
+    });
   }
   checkCircle() {
-    // this._sortedProjects = sortProjects(this._projects);
-    this._checkForCyclicDependencies(this._projects, [], new Set());
-  }
-  async traverseDependenciesToProjectToDependent(name, task, config = {}) {
-    await this.traverseDependenciesToProject(name, task, config);
-    await this.traverseProjectToDependent(name, task, _objectSpread(_objectSpread({}, 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, _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 _task.TaskRunner(leafNodeTasks, {
-      concurrency: runTaskConcurrency
+    this._checkForCyclicDependencies(this._projects, [], /* @__PURE__ */ new Set());
+  }
+  traverseDependenciesToProjectToDependent(_0, _1) {
+    return __async(this, arguments, function* (name, task, config = {}) {
+      yield this.traverseDependenciesToProject(name, task, config);
+      yield this.traverseProjectToDependent(name, task, __spreadProps(__spreadValues({}, config), {
+        withSelf: false
+      }));
     });
-    const edgeManager = new _edgeManager.EdgeManager();
-    taskRunner.on(_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));
-        }
+  }
+  traverseProjectToDependent(_0, _1) {
+    return __async(this, arguments, function* (name, task, { withSelf = false, runTaskConcurrency } = {}) {
+      if (!this._projectsMap.has(name)) {
+        (0, import_error.errorLog)(`No '${name}' project exist`);
       }
-    });
-    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, _error.errorLog)(`No '${name}' project exist`);
-    }
-    const traverseTargetNode = this._projectsMap.get(name);
-    const leafNodes = this._getDependencyLeafNodes(traverseTargetNode);
-    if ((leafNodes === null || leafNodes === void 0 ? void 0 : leafNodes.length) === 0) {
-      await this._createTask(traverseTargetNode, task)();
-      return;
-    }
-    const leafNodeTasks = leafNodes.map(project => this._createTask(project, task));
-    const taskRunner = new _task.TaskRunner(leafNodeTasks, {
-      concurrency: runTaskConcurrency
-    });
-    const edgeManager = new _edgeManager.EdgeManager();
-    taskRunner.on(_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));
+      const traverseTargetNode = this._projectsMap.get(name);
+      const leafNodeTasks = [
+        withSelf ? this._createTask(traverseTargetNode, task) : () => __async(this, null, function* () {
+          return 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));
+          }
         }
+      });
+      yield taskRunner.run();
+    });
+  }
+  traverseDependenciesToProject(_0, _1) {
+    return __async(this, arguments, function* (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) {
+        yield 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));
+          }
+        }
+      });
+      yield taskRunner.run();
     });
-    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  -> ')}\n`);
+        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);
+        this._checkForCyclicDependencies(
+          project.dependent,
+          dependencyChain,
+          alreadyCheckedProjects
+        );
         dependencyChain.pop();
       }
     }
@@ -223,19 +261,16 @@ class DagOperator {
     }
     let leafNodes = [...dependency];
     for (const dependencyNode of dependency) {
-      leafNodes = [...leafNodes, ...this._getDependencyLeafNodes(dependencyNode)];
+      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);
-  //   }
-  // }
+    return searchProjects.filter(
+      (p) => preNodes.map((preP) => preP.name).includes(p.name)
+    );
+  }
 }
-exports.DagOperator = DagOperator;

package/dist/js/node/dag/task.js

@@ -1,62 +1,104 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 stdin_exports = {};
+__export(stdin_exports, {
+  TaskRunner: () => TaskRunner
 });
-exports.TaskRunner = void 0;
-var _events = require("events");
-var _pMap = _interopRequireDefault(require("p-map"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function _defineProperty(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; }
-class TaskRunner extends _events.EventEmitter {
-  constructor(tasks, {
-    concurrency
-  }) {
+module.exports = __toCommonJS(stdin_exports);
+var import_events = require("events");
+var import_p_map = __toESM(require("p-map"));
+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());
+  });
+};
+const _TaskRunner = class extends import_events.EventEmitter {
+  constructor(tasks, { concurrency }) {
     super();
-    _defineProperty(this, "_tasks", void 0);
-    _defineProperty(this, "_concurrency", void 0);
-    _defineProperty(this, "_usableConcurrency", void 0);
-    _defineProperty(this, "_stopFlag", void 0);
     this._tasks = tasks;
-    this._concurrency = concurrency || TaskRunner.DefaultConcurrency;
+    this._concurrency = concurrency || _TaskRunner.DefaultConcurrency;
     this._usableConcurrency = this._concurrency;
     this._stopFlag = false;
   }
-  async run() {
-    const tasks = this._tasks.splice(0, this._concurrency);
-    this._usableConcurrency = this._concurrency - tasks.length;
-    await (0, _pMap.default)(tasks, async task => {
-      await this._runTask(task);
-    }, {
-      concurrency: tasks.length
+  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 }
+      );
     });
   }
   addTask(task) {
     this._tasks.push(task);
   }
-  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, _pMap.default)(nextTasks, async _task => {
-          await this._runTask(_task);
-        }, {
-          concurrency: nextTasks.length
-        });
+  _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 }
+          );
+        }
+      }
+    });
   }
   _stopTask() {
     this._stopFlag = true;
   }
-}
-exports.TaskRunner = TaskRunner;
-_defineProperty(TaskRunner, "DefaultConcurrency", 10);
-_defineProperty(TaskRunner, "TASK_FINISH", 'task-finish');
+};
+let TaskRunner = _TaskRunner;
+TaskRunner.DefaultConcurrency = 10;
+TaskRunner.TASK_FINISH = "task-finish";