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

package/dist/js/modern/dag/task.js

@@ -1,54 +1,79 @@
-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; }
-import { EventEmitter } from 'events';
-import pMap from 'p-map';
-export class TaskRunner extends EventEmitter {
-  constructor(tasks, {
-    concurrency
-  }) {
+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());
+  });
+};
+import { EventEmitter } from "events";
+import pMap from "p-map";
+const _TaskRunner = class extends 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 pMap(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 pMap(
+        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 pMap(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 pMap(
+            nextTasks,
+            (_task) => __async(this, null, function* () {
+              yield this._runTask(_task);
+            }),
+            { concurrency: nextTasks.length }
+          );
+        }
+      }
+    });
   }
   _stopTask() {
     this._stopFlag = true;
   }
-}
-_defineProperty(TaskRunner, "DefaultConcurrency", 10);
-_defineProperty(TaskRunner, "TASK_FINISH", 'task-finish');
+};
+let TaskRunner = _TaskRunner;
+TaskRunner.DefaultConcurrency = 10;
+TaskRunner.TASK_FINISH = "task-finish";
+export {
+  TaskRunner
+};

package/dist/js/modern/dag/utils.js

@@ -1,78 +1,67 @@
 import { errorLog } from "../log/error";
 import { EdgeManager } from "./edge-manager";
-
-/**
- * Calculate the number of packages which must be built before we reach
- * the furthest away "root" node
- */
-export const calculateCriticalPaths = project => {
-  var _project$dependent;
-  // Return the memoized value
-  if (project.criticalPathLength !== undefined) {
+const calculateCriticalPaths = (project) => {
+  var _a, _b;
+  if (project.criticalPathLength !== void 0) {
     return project.criticalPathLength;
   }
-
-  // If no dependents, we are in a "root"
-  if (((_project$dependent = project.dependent) === null || _project$dependent === void 0 ? void 0 : _project$dependent.length) === 0) {
+  if (((_a = project.dependent) == null ? void 0 : _a.length) === 0) {
     project.criticalPathLength = 0;
     return project.criticalPathLength;
   } else {
-    var _project$dependent2;
-    // Otherwise we are as long as the longest package + 1
     const depsLengths = [];
-    (_project$dependent2 = project.dependent) === null || _project$dependent2 === void 0 ? void 0 : _project$dependent2.forEach(dependentProject => depsLengths.push(calculateCriticalPaths(dependentProject)));
+    (_b = project.dependent) == null ? void 0 : _b.forEach(
+      (dependentProject) => depsLengths.push(calculateCriticalPaths(dependentProject))
+    );
     project.criticalPathLength = Math.max(...depsLengths) + 1;
     return project.criticalPathLength;
   }
 };
-const _recursiveGetDependencySkipCircleDeps = node => {
+const _recursiveGetDependencySkipCircleDeps = (node) => {
   let allDeps = [];
-  const foundDepsNameSet = new Set([node.name]);
+  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));
+      const willIntoQueue = checkNodeDeps.filter(
+        (dep) => !foundDepsNameSet.has(dep.name)
+      );
       allDeps = [...allDeps, ...willIntoQueue];
-      willIntoQueue.forEach(dep => foundDepsNameSet.add(dep.name));
+      willIntoQueue.forEach((dep) => foundDepsNameSet.add(dep.name));
       queue = [...queue, ...willIntoQueue];
     }
   }
   return allDeps;
 };
-export const recursiveGetDependency = (project, skipCircleProjects = false) => {
+const recursiveGetDependency = (project, skipCircleProjects = false) => {
   if (skipCircleProjects) {
     return _recursiveGetDependencySkipCircleDeps(project);
   }
   const dependency = project.dependency || [];
   let allDependency = [...dependency];
   for (const dependencyProject of dependency) {
-    allDependency = [...allDependency, ...recursiveGetDependency(dependencyProject)];
+    allDependency = [
+      ...allDependency,
+      ...recursiveGetDependency(dependencyProject)
+    ];
   }
   return allDependency;
 };
-
-// 拓扑排序
-export const sortProjects = projects => {
-  const sortedQueue = []; // 排好序的队列
-  let readyIntoSortedQueue = []; // 用来准备放入 sortedQueue的数组
-  let queue = []; // 用来存放入度为0的节点
+const sortProjects = (projects) => {
+  const sortedQueue = [];
+  let readyIntoSortedQueue = [];
+  let queue = [];
   const edgeManager = new EdgeManager();
-  // 初始化队列queue
   for (const project of projects) {
     edgeManager.setEdge(project);
-    // 入度为0进队列
-    // TODO 可能存在多个 dagNodeFrom === 0 的节点
     if (edgeManager.getEdge(project) === 0) {
       queue.push(project);
     }
   }
-
-  // 加入最初入度为0的节点
   sortedQueue.push([...queue]);
-  let shiftNodesCount = 0; // 计算出队列的节点数量，用于在最后判断是否存在环/依赖循环
-
+  let shiftNodesCount = 0;
   while (queue.length > 0) {
     const checkNode = queue.shift();
     shiftNodesCount++;
@@ -89,13 +78,12 @@ export const sortProjects = projects => {
     }
   }
   if (shiftNodesCount < projects.length) {
-    errorLog('Items with a dependency loop');
+    errorLog("Items with a dependency loop");
   } else {
-    // console.info('No dependency loop');
   }
   return sortedQueue;
 };
-export const findCircle = projects => {
+const findCircle = (projects) => {
   let result = projects.reduce((circleNodes, project) => {
     if (project.dependencyEdge > 0) {
       return [...circleNodes, project];
@@ -107,4 +95,10 @@ export const findCircle = projects => {
     const checkNode = result.shift();
     checkNode.dependencyEdge--;
   }
-};
+};
+export {
+  calculateCriticalPaths,
+  findCircle,
+  recursiveGetDependency,
+  sortProjects
+};

package/dist/js/modern/features/build/index.js

@@ -1,6 +1,29 @@
-import os from 'os';
-import { execa, signale } from '@modern-js/utils';
-import { checkProjectChangeByGit, checkProjectChangeByContent } from "../../projects/check-project-change";
+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());
+  });
+};
+import os from "os";
+import { execa, signale } from "@modern-js/utils";
+import {
+  checkProjectChangeByGit,
+  checkProjectChangeByContent
+} from "../../projects/check-project-change";
 import { errorLog } from "../../log/error";
 import { MultitasksLogger } from "../../log/multi-tasks-log";
 const createTask = (config, taskCmds = defaultBuildCmds, taskLogger) => {
@@ -10,18 +33,17 @@ const createTask = (config, taskCmds = defaultBuildCmds, taskLogger) => {
     disableContentHash = false,
     enableGitHash = false
   } = config;
-  const task = async project => {
-    console.info('run ', project.name);
-    // const taskTimeLog = timeLog.initTimeLog({ scope: '' });
+  const task = (project) => __async(void 0, null, function* () {
+    console.info("run ", project.name);
     if (!disableContentHash) {
-      const changed = await checkProjectChangeByContent(project);
+      const changed = yield checkProjectChangeByContent(project);
       if (!changed) {
         console.info(`${project.name} content not change, skip`);
         return;
       }
     }
     if (enableGitHash) {
-      const changed = await checkProjectChangeByGit(project, rootPath);
+      const changed = yield checkProjectChangeByGit(project, rootPath);
       if (!changed) {
         console.info(`${project.name} not change, skip`);
         return;
@@ -32,22 +54,18 @@ const createTask = (config, taskCmds = defaultBuildCmds, taskLogger) => {
     for (const taskCmd of taskCmds) {
       if (cmd[taskCmd]) {
         const prefix = `run ${project.name} ${taskCmd} script`;
-        // timeLog.startTime(taskTimeLog, prefix);
         signale.time(prefix);
         try {
           const childProcess = execa(packageManager, [taskCmd], {
             cwd: project.extra.path,
-            stdio: ['pipe', 'pipe', 'pipe']
+            stdio: ["pipe", "pipe", "pipe"]
           });
           taskLogger.addLogProvider(project.name, {
             stdout: childProcess.stdout,
             stderr: childProcess.stderr,
-            logConfig: {
-              label: 'BUILD: '
-            }
+            logConfig: { label: "BUILD: " }
           });
-          await childProcess;
-          // timeLog.endTime(taskTimeLog, prefix);
+          yield childProcess;
           signale.timeEnd(prefix);
         } catch (e) {
           errorLog(project.name, e.message);
@@ -56,11 +74,11 @@ const createTask = (config, taskCmds = defaultBuildCmds, taskLogger) => {
         console.info(`${project.name} not have ${taskCmd}, skip it.`);
       }
     }
-  };
+  });
   return task;
 };
-const defaultBuildCmds = ['build'];
-export const runBuildTask = async (projectName, operator, config, taskCmds = defaultBuildCmds) => {
+const defaultBuildCmds = ["build"];
+const runBuildTask = (_0, _1, _2, ..._3) => __async(void 0, [_0, _1, _2, ..._3], function* (projectName, operator, config, taskCmds = defaultBuildCmds) {
   const {
     withSelf = true,
     onlySelf = false,
@@ -69,18 +87,15 @@ export const runBuildTask = async (projectName, operator, config, taskCmds = def
   } = config;
   const taskLogger = new MultitasksLogger();
   const task = createTask(config, taskCmds, taskLogger);
-  // 优先级 onlySelf > withDept、disableWithDeps
   if (onlySelf) {
-    await task(operator.getNodeData(projectName, {
-      checkExist: true
-    }));
+    yield task(operator.getNodeData(projectName, { checkExist: true }));
   } else if (!disableWithDeps && withDept) {
-    await operator.traverseDependenciesToProjectToDependent(projectName, task, {
+    yield operator.traverseDependenciesToProjectToDependent(projectName, task, {
       withSelf,
       runTaskConcurrency: os.cpus().length
     });
   } else if (disableWithDeps && withDept) {
-    await operator.traverseProjectToDependent(projectName, task, {
+    yield operator.traverseProjectToDependent(projectName, task, {
       withSelf,
       runTaskConcurrency: os.cpus().length
     });
@@ -90,9 +105,13 @@ export const runBuildTask = async (projectName, operator, config, taskCmds = def
       runTaskConcurrency: os.cpus().length
     });
   }
-};
-export const runAllBuildTask = async (operator, config, taskCmds = defaultBuildCmds) => {
+});
+const runAllBuildTask = (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (operator, config, taskCmds = defaultBuildCmds) {
   const taskLogger = new MultitasksLogger();
   const task = createTask(config, taskCmds, taskLogger);
-  await operator.traverseAllNodes(task);
-};
+  yield operator.traverseAllNodes(task);
+});
+export {
+  runAllBuildTask,
+  runBuildTask
+};

package/dist/js/modern/features/clear/index.js

@@ -1,16 +1,13 @@
-import * as path from 'path';
-import { logger } from '@modern-js/utils';
-import { FileSystem } from '@rushstack/node-core-library';
-export const defaultRemoveDirs = ['node_modules'];
-export const runClearTask = (projectNames, projects, config) => {
-  const {
-    removeDirs = defaultRemoveDirs,
-    rootPath
-  } = config;
+import * as path from "path";
+import { logger } from "@modern-js/utils";
+import { FileSystem } from "@rushstack/node-core-library";
+const defaultRemoveDirs = ["node_modules"];
+const runClearTask = (projectNames, projects, config) => {
+  const { removeDirs = defaultRemoveDirs, rootPath } = config;
   if (projectNames.length > 0) {
-    projects.forEach(project => {
+    projects.forEach((project) => {
       if (projectNames.includes(project.name)) {
-        removeDirs.forEach(dir => {
+        removeDirs.forEach((dir) => {
           const removePath = path.join(`${project.extra.path}`, dir);
           logger.info(`remove ${removePath}`);
           FileSystem.deleteFolder(removePath);
@@ -18,17 +15,21 @@ export const runClearTask = (projectNames, projects, config) => {
       }
     });
   } else {
-    removeDirs.forEach(dir => {
+    removeDirs.forEach((dir) => {
       const removePath = path.join(`${rootPath}`, dir);
       logger.info(`remove ${removePath}`);
       FileSystem.deleteFolder(removePath);
     });
-    projects.forEach(project => {
-      removeDirs.forEach(dir => {
+    projects.forEach((project) => {
+      removeDirs.forEach((dir) => {
         const removePath = path.join(`${project.extra.path}`, dir);
         logger.info(`remove ${removePath}`);
         FileSystem.deleteFolder(removePath);
       });
     });
   }
-};
+};
+export {
+  defaultRemoveDirs,
+  runClearTask
+};