@modern-js/monorepo-tools 2.14.0 → 2.16.0

package/dist/cjs/dag/operator.js

@@ -1,91 +1,80 @@
-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
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-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_edgeManager = require("./edgeManager");
-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 = [];
+Object.defineProperty(exports, "DagOperator", {
+  enumerable: true,
+  get: () => DagOperator
+});
+const _pmap = /* @__PURE__ */ _interop_require_default(require("p-map"));
+const _error = require("../log/error");
+const _task = require("./task");
+const _edgeManager = require("./edgeManager");
+const _utils = require("./utils");
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
   }
+  return obj;
+}
+function _interop_require_default(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+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, import_error.errorLog)(`No '${name}' project exist`);
+        (0, _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) || [];
+    var _this__projectsMap_get;
+    return ((_this__projectsMap_get = this._projectsMap.get(name)) === null || _this__projectsMap_get === void 0 ? void 0 : _this__projectsMap_get.dependency) || [];
   }
   getNodeDependentData(name) {
-    var _a;
-    return ((_a = this._projectsMap.get(name)) == null ? void 0 : _a.dependent) || [];
+    var _this__projectsMap_get;
+    return ((_this__projectsMap_get = this._projectsMap.get(name)) === null || _this__projectsMap_get === void 0 ? void 0 : _this__projectsMap_get.dependent) || [];
   }
-  getNodeAllDependencyData(name, option = { skipCircleCheck: false }) {
+  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`);
+      (0, _error.errorLog)(`No '${name}' project exist`);
     }
     const currentNode = this._projectsMap.get(name);
-    return (0, import_utils.recursiveGetDependency)(currentNode, skipCircleCheck);
+    return (0, _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`);
+      (0, _error.errorLog)(`No '${name}' project exist`);
     }
   }
   async traverseAllNodes(task) {
-    const sortedNodes = this._sortedProjects.length > 0 ? this._sortedProjects : (0, import_utils.sortProjects)(this._projects);
+    const sortedNodes = this._sortedProjects.length > 0 ? this._sortedProjects : (0, _utils.sortProjects)(this._projects);
     const finishTaskHash = {};
     let preNodes = [];
     let earlyFinish = false;
@@ -93,22 +82,22 @@ class DagOperator {
       if (earlyFinish) {
         break;
       }
-      await (0, import_p_map.default)(
+      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
-            );
+            await task(project, this._getProjectPreviousNode(project.dependent || [], preNodes), () => earlyFinish = true);
           }
         },
-        { concurrency: projects.length }
+        {
+          concurrency: projects.length
+        }
       );
-      preNodes = [...projects];
+      preNodes = [
+        ...projects
+      ];
     }
   }
   checkCircle() {
@@ -122,35 +111,34 @@ class DagOperator {
     });
   }
   /**
-   * 1. 把目标节点当做叶子节点集合 A 中的元素
-   * 2. 当叶子节点集合中某个 a 元素结束任务的时候进行如下操作：
-   * 2.1 剪(去额外的)枝：获取 a 元素的 dependent集合，将该集合中元素的依赖列表进行过滤，过滤条件为：排除 a 以及 a 元素的 dependent集合以外的元素。
-   * 2.2 入度减一：对 a 元素的 dependent 集合元素的 dependencyEdge 减一
-   * 3. 检查是否存在 dependencyEdge === 0 的节点，加入叶子节点集合 A中。
-   * 4. 根据情况（是否存在空闲的进程）选择是否执行新加入的节点对应的任务。
-   */
+  * 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`);
+      (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 import_task.TaskRunner(leafNodeTasks, {
+    const taskRunner = new _task.TaskRunner(leafNodeTasks, {
       concurrency: runTaskConcurrency
     });
-    const edgeManager = new import_edgeManager.EdgeManager();
-    taskRunner.on(import_task.TaskRunner.TASK_FINISH, (projectName) => {
+    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
-          )
-        );
+        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));
@@ -160,37 +148,36 @@ class DagOperator {
     await taskRunner.run();
   }
   /**
-   * 1. 找到叶子节点集合 A
-   * 2. 找到直接连接叶子节点的节点集合 B
-   * 3. 当有某个叶子节点结束任务，则对该节点的直接连接的节点（或者理解成dependent）的枝数（或者叫入度）减一。
-   * 4. 检查 B 集合中是否存在入度为0的节点，则此节点为叶子节点，并加入叶子节点集合 A
-   * 5. 根据情况（是否存在空闲的进程）选择是否执行新加入的节点对应的任务。
-   */
+  * 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`);
+      (0, _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) {
+    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 import_task.TaskRunner(leafNodeTasks, {
+    const leafNodeTasks = leafNodes.map((project) => this._createTask(project, task));
+    const taskRunner = new _task.TaskRunner(leafNodeTasks, {
       concurrency: runTaskConcurrency
     });
-    const edgeManager = new import_edgeManager.EdgeManager();
-    taskRunner.on(import_task.TaskRunner.TASK_FINISH, (projectName) => {
+    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
-        )) {
+        if (![
+          traverseTargetNode,
+          ...leafNodes
+        ].some((n) => n.name === dependentProject.name)) {
           continue;
         }
         edgeManager.reduceOneEdge(dependentProject);
@@ -217,22 +204,16 @@ class DagOperator {
   _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  -> ")}
-`
-        );
+        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();
       }
     }
@@ -242,7 +223,9 @@ class DagOperator {
     if (dependency.length === 0) {
       return [];
     }
-    let leafNodes = [...dependency];
+    let leafNodes = [
+      ...dependency
+    ];
     for (const dependencyNode of dependency) {
       leafNodes = [
         ...leafNodes,
@@ -252,18 +235,18 @@ class DagOperator {
     return leafNodes;
   }
   _getProjectPreviousNode(searchProjects, preNodes) {
-    return searchProjects.filter(
-      (p) => preNodes.map((preP) => preP.name).includes(p.name)
-    );
+    return searchProjects.filter((p) => preNodes.map((preP) => preP.name).includes(p.name));
+  }
+  constructor(projects, projectsMap) {
+    _define_property(this, "_projects", void 0);
+    _define_property(this, "_projectsMap", void 0);
+    _define_property(this, "_sortedProjects", void 0);
+    _define_property(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 = [];
   }
-  // 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/cjs/dag/task.js

@@ -1,55 +1,40 @@
-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 task_exports = {};
-__export(task_exports, {
-  TaskRunner: () => TaskRunner
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(task_exports);
-var import_events = require("events");
-var import_p_map = __toESM(require("p-map"));
-const _TaskRunner = class extends import_events.EventEmitter {
-  constructor(tasks, { concurrency }) {
-    super();
-    this._tasks = tasks;
-    this._concurrency = concurrency || _TaskRunner.DefaultConcurrency;
-    this._usableConcurrency = this._concurrency;
-    this._stopFlag = false;
+Object.defineProperty(exports, "TaskRunner", {
+  enumerable: true,
+  get: () => TaskRunner
+});
+const _events = require("events");
+const _pmap = /* @__PURE__ */ _interop_require_default(require("p-map"));
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
   }
+  return obj;
+}
+function _interop_require_default(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+class TaskRunner extends _events.EventEmitter {
   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 }
-    );
+    await (0, _pmap.default)(tasks, async (task) => {
+      await this._runTask(task);
+    }, {
+      concurrency: tasks.length
+    });
   }
   addTask(task) {
     this._tasks.push(task);
@@ -60,29 +45,33 @@ const _TaskRunner = class extends import_events.EventEmitter {
     }
     const emitValue = await task(this._stopTask.bind(this));
     this._usableConcurrency--;
-    this.emit(_TaskRunner.TASK_FINISH, emitValue);
+    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 }
-        );
+        await (0, _pmap.default)(nextTasks, async (_task) => {
+          await this._runTask(_task);
+        }, {
+          concurrency: nextTasks.length
+        });
       }
     }
   }
   _stopTask() {
     this._stopFlag = true;
   }
-};
-let TaskRunner = _TaskRunner;
-TaskRunner.DefaultConcurrency = 10;
-TaskRunner.TASK_FINISH = "task-finish";
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TaskRunner
-});
+  constructor(tasks, { concurrency }) {
+    super();
+    _define_property(this, "_tasks", void 0);
+    _define_property(this, "_concurrency", void 0);
+    _define_property(this, "_usableConcurrency", void 0);
+    _define_property(this, "_stopFlag", void 0);
+    this._tasks = tasks;
+    this._concurrency = concurrency || TaskRunner.DefaultConcurrency;
+    this._usableConcurrency = this._concurrency;
+    this._stopFlag = false;
+  }
+}
+_define_property(TaskRunner, "DefaultConcurrency", 10);
+_define_property(TaskRunner, "TASK_FINISH", "task-finish");

package/dist/cjs/dag/utils.js

@@ -1,61 +1,60 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
   calculateCriticalPaths: () => calculateCriticalPaths,
-  findCircle: () => findCircle,
   recursiveGetDependency: () => recursiveGetDependency,
-  sortProjects: () => sortProjects
+  sortProjects: () => sortProjects,
+  findCircle: () => findCircle
 });
-module.exports = __toCommonJS(utils_exports);
-var import_error = require("../log/error");
-var import_edgeManager = require("./edgeManager");
+const _error = require("../log/error");
+const _edgeManager = require("./edgeManager");
 const calculateCriticalPaths = (project) => {
-  var _a, _b;
+  var _project_dependent;
   if (project.criticalPathLength !== void 0) {
     return project.criticalPathLength;
   }
-  if (((_a = project.dependent) == null ? void 0 : _a.length) === 0) {
+  if (((_project_dependent = project.dependent) === null || _project_dependent === void 0 ? void 0 : _project_dependent.length) === 0) {
     project.criticalPathLength = 0;
     return project.criticalPathLength;
   } else {
+    var _project_dependent1;
     const depsLengths = [];
-    (_b = project.dependent) == null ? void 0 : _b.forEach(
-      (dependentProject) => depsLengths.push(calculateCriticalPaths(dependentProject))
-    );
+    (_project_dependent1 = project.dependent) === null || _project_dependent1 === void 0 ? void 0 : _project_dependent1.forEach((dependentProject) => depsLengths.push(calculateCriticalPaths(dependentProject)));
     project.criticalPathLength = Math.max(...depsLengths) + 1;
     return project.criticalPathLength;
   }
 };
 const _recursiveGetDependencySkipCircleDeps = (node) => {
   let allDeps = [];
-  const foundDepsNameSet = /* @__PURE__ */ new Set([node.name]);
-  let queue = [node];
+  const foundDepsNameSet = /* @__PURE__ */ new Set([
+    node.name
+  ]);
+  let queue = [
+    node
+  ];
   while (queue.length > 0) {
     const checkNode = queue.pop();
     const checkNodeDeps = checkNode.dependency || [];
     if (checkNodeDeps.length > 0) {
-      const willIntoQueue = checkNodeDeps.filter(
-        (dep) => !foundDepsNameSet.has(dep.name)
-      );
-      allDeps = [...allDeps, ...willIntoQueue];
+      const willIntoQueue = checkNodeDeps.filter((dep) => !foundDepsNameSet.has(dep.name));
+      allDeps = [
+        ...allDeps,
+        ...willIntoQueue
+      ];
       willIntoQueue.forEach((dep) => foundDepsNameSet.add(dep.name));
-      queue = [...queue, ...willIntoQueue];
+      queue = [
+        ...queue,
+        ...willIntoQueue
+      ];
     }
   }
   return allDeps;
@@ -65,7 +64,9 @@ const recursiveGetDependency = (project, skipCircleProjects = false) => {
     return _recursiveGetDependencySkipCircleDeps(project);
   }
   const dependency = project.dependency || [];
-  let allDependency = [...dependency];
+  let allDependency = [
+    ...dependency
+  ];
   for (const dependencyProject of dependency) {
     allDependency = [
       ...allDependency,
@@ -78,14 +79,16 @@ const sortProjects = (projects) => {
   const sortedQueue = [];
   let readyIntoSortedQueue = [];
   let queue = [];
-  const edgeManager = new import_edgeManager.EdgeManager();
+  const edgeManager = new _edgeManager.EdgeManager();
   for (const project of projects) {
     edgeManager.setEdge(project);
     if (edgeManager.getEdge(project) === 0) {
       queue.push(project);
     }
   }
-  sortedQueue.push([...queue]);
+  sortedQueue.push([
+    ...queue
+  ]);
   let shiftNodesCount = 0;
   while (queue.length > 0) {
     const checkNode = queue.shift();
@@ -97,13 +100,17 @@ const sortProjects = (projects) => {
       }
     }
     if (queue.length === 0 && readyIntoSortedQueue.length > 0) {
-      queue = [...readyIntoSortedQueue];
-      sortedQueue.push([...readyIntoSortedQueue]);
+      queue = [
+        ...readyIntoSortedQueue
+      ];
+      sortedQueue.push([
+        ...readyIntoSortedQueue
+      ]);
       readyIntoSortedQueue = [];
     }
   }
   if (shiftNodesCount < projects.length) {
-    (0, import_error.errorLog)("Items with a dependency loop");
+    (0, _error.errorLog)("Items with a dependency loop");
   } else {
   }
   return sortedQueue;
@@ -111,7 +118,10 @@ const sortProjects = (projects) => {
 const findCircle = (projects) => {
   let result = projects.reduce((circleNodes, project) => {
     if (project.dependencyEdge > 0) {
-      return [...circleNodes, project];
+      return [
+        ...circleNodes,
+        project
+      ];
     }
     return circleNodes;
   }, []);
@@ -121,10 +131,3 @@ const findCircle = (projects) => {
     checkNode.dependencyEdge--;
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  calculateCriticalPaths,
-  findCircle,
-  recursiveGetDependency,
-  sortProjects
-});