@modern-js/monorepo-tools 2.4.0 → 2.5.0

package/dist/esm/dag/operator.js

@@ -0,0 +1,203 @@
+import pMap from "p-map";
+import { errorLog } from "../log/error";
+import { TaskRunner } from "./task";
+import { EdgeManager } from "./edge-manager";
+import { recursiveGetDependency, sortProjects } from "./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 {
+        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)) {
+      errorLog(`No '${name}' project exist`);
+    }
+    const currentNode = this._projectsMap.get(name);
+    return recursiveGetDependency(currentNode, skipCircleCheck);
+  }
+  setNodeData(name, task) {
+    if (this._projectsMap.has(name)) {
+      task(this._projectsMap.get(name));
+    } else {
+      errorLog(`No '${name}' project exist`);
+    }
+  }
+  async traverseAllNodes(task) {
+    const sortedNodes = this._sortedProjects.length > 0 ? this._sortedProjects : sortProjects(this._projects);
+    const finishTaskHash = {};
+    let preNodes = [];
+    let earlyFinish = false;
+    for (const projects of sortedNodes) {
+      if (earlyFinish) {
+        break;
+      }
+      await pMap(
+        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)) {
+      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 TaskRunner(leafNodeTasks, {
+      concurrency: runTaskConcurrency
+    });
+    const edgeManager = new EdgeManager();
+    taskRunner.on(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)) {
+      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 TaskRunner(leafNodeTasks, {
+      concurrency: runTaskConcurrency
+    });
+    const edgeManager = new EdgeManager();
+    taskRunner.on(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)
+    );
+  }
+}
+export {
+  DagOperator
+};

package/dist/esm/dag/task.js

@@ -0,0 +1,55 @@
+import { EventEmitter } from "events";
+import pMap from "p-map";
+const _TaskRunner = class extends EventEmitter {
+  constructor(tasks, { concurrency }) {
+    super();
+    this._tasks = tasks;
+    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 }
+    );
+  }
+  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 }
+        );
+      }
+    }
+  }
+  _stopTask() {
+    this._stopFlag = true;
+  }
+};
+let TaskRunner = _TaskRunner;
+TaskRunner.DefaultConcurrency = 10;
+TaskRunner.TASK_FINISH = "task-finish";
+export {
+  TaskRunner
+};

package/dist/{js/modern → esm}/features/build/index.js

@@ -1,23 +1,3 @@
-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 {
@@ -33,17 +13,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 checkProjectChangeByContent(project);
+      const changed = await checkProjectChangeByContent(project);
       if (!changed) {
         console.info(`${project.name} content not change, skip`);
         return;
       }
     }
     if (enableGitHash) {
-      const changed = yield checkProjectChangeByGit(project, rootPath);
+      const changed = await checkProjectChangeByGit(project, rootPath);
       if (!changed) {
         console.info(`${project.name} not change, skip`);
         return;
@@ -65,7 +45,7 @@ const createTask = (config, taskCmds = defaultBuildCmds, taskLogger) => {
             stderr: childProcess.stderr,
             logConfig: { label: "BUILD: " }
           });
-          yield childProcess;
+          await childProcess;
           signale.timeEnd(prefix);
         } catch (e) {
           errorLog(project.name, e.message);
@@ -74,11 +54,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,
@@ -88,14 +68,14 @@ const runBuildTask = (_0, _1, _2, ..._3) => __async(void 0, [_0, _1, _2, ..._3],
   const taskLogger = new 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: os.cpus().length
     });
   } else if (disableWithDeps && withDept) {
-    yield operator.traverseProjectToDependent(projectName, task, {
+    await operator.traverseProjectToDependent(projectName, task, {
       withSelf,
       runTaskConcurrency: os.cpus().length
     });
@@ -105,12 +85,12 @@ const runBuildTask = (_0, _1, _2, ..._3) => __async(void 0, [_0, _1, _2, ..._3],
       runTaskConcurrency: os.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 MultitasksLogger();
   const task = createTask(config, taskCmds, taskLogger);
-  yield operator.traverseAllNodes(task);
-});
+  await operator.traverseAllNodes(task);
+};
 export {
   runAllBuildTask,
   runBuildTask

package/dist/{js/modern → esm}/features/deploy/index.js

@@ -1,23 +1,3 @@
-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 * as path from "path";
 import {
   FileSystem,
@@ -85,7 +65,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) {
@@ -94,7 +74,7 @@ const checkAndRunDeployCommand = (monorepoPath, targetProject, packageManager) =
     );
     let runDeployCommands = ["run", "deploy"];
     if (packageManager === "pnpm") {
-      const pnpmVersion = yield getPnpmVersion();
+      const pnpmVersion = await getPnpmVersion();
       if (pnpmVersion.startsWith("6")) {
         runDeployCommands = ["run", "deploy", "--filter", targetProject.name];
       } else {
@@ -110,10 +90,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 = JsonFile.load(packageJsonPath);
   const scripts = (packageJson == null ? void 0 : packageJson.scripts) || {};
@@ -135,11 +115,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);
   FileSystem.deleteFolder(realDeployPath);
@@ -154,7 +134,7 @@ const deploy = (deployProjectNames, operator, config) => __async(void 0, null, f
       alldeps,
       realDeployPath
     );
-    yield checkAndRunDeployCommand(rootPath, currentProject, packageManager);
+    await checkAndRunDeployCommand(rootPath, currentProject, packageManager);
     FileSystem.ensureFolder(realDeployPath);
     for (const [from, to] of copyMap) {
       FileSystem.copyFiles({
@@ -172,7 +152,7 @@ const deploy = (deployProjectNames, operator, config) => __async(void 0, null, f
   }
   generatorAndCopyRequiredFiles(rootPath, realDeployPath);
   logger.success(`Deploy success. The deploy dir is in '${rootPath}/output'`);
-});
+};
 export {
   deploy
 };

package/dist/{js/modern → esm}/features/dev/create-task.js

@@ -1,23 +1,3 @@
-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 { execa, logger } from "@modern-js/utils";
 import { errorLog } from "../../log/error";
 import * as timeLog from "../../log/time";
@@ -38,7 +18,7 @@ const getFinalTaskCmds = (taskCmds, project) => {
 const createDependenciesTask = (config, taskCmds = 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) {
@@ -55,7 +35,7 @@ const createDependenciesTask = (config, taskCmds = defaultBuildWatchCmds, taskLo
             stderr: childProcess.stderr,
             logConfig: { label: "WATCH: " }
           });
-          yield childProcess;
+          await childProcess;
         } catch (e) {
           errorLog(project.name, e);
         }
@@ -64,12 +44,12 @@ const createDependenciesTask = (config, taskCmds = defaultBuildWatchCmds, taskLo
         logger.info(`${project.name} not have ${taskCmd}, skip it.`);
       }
     }
-  });
+  };
   return task;
 };
 const createDevTask = (config, taskCmds = 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) {
@@ -85,7 +65,7 @@ const createDevTask = (config, taskCmds = defaultBuildWatchCmds, taskLogger) =>
             stderr: childProcess.stderr,
             logConfig: { label: `${taskCmd.toUpperCase()}: ` }
           });
-          const ret = yield childProcess;
+          const ret = await childProcess;
           console.info(ret);
         } catch (e) {
           errorLog(project.name, e);
@@ -94,7 +74,7 @@ const createDevTask = (config, taskCmds = defaultBuildWatchCmds, taskLogger) =>
         logger.info(`${project.name} not have ${taskCmd}, skip it.`);
       }
     }
-  });
+  };
   return task;
 };
 export {

package/dist/{js/modern → esm}/features/dev/index.js

@@ -1,23 +1,3 @@
-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 anymatch from "anymatch";
 import { chokidar } from "@modern-js/utils";
 import { MultitasksLogger } from "../../log/multi-tasks-log";
@@ -34,7 +14,7 @@ const getIgnored = (config) => (watchFilePath) => {
   }
   return false;
 };
-const runBuildWatchTask = (_0, _1, _2, ..._3) => __async(void 0, [_0, _1, _2, ..._3], function* (projectName, operator, config, taskCmds = defaultBuildWatchCmds) {
+const runBuildWatchTask = async (projectName, operator, config, taskCmds = defaultBuildWatchCmds) => {
   const { needInit = true } = config;
   const taskLogger = new MultitasksLogger();
   const dependenciesTask = createDependenciesTask(config, taskCmds, taskLogger);
@@ -52,24 +32,24 @@ const runBuildWatchTask = (_0, _1, _2, ..._3) => __async(void 0, [_0, _1, _2, ..
   });
   watcher.add(watchedProjectState.getWatchedProjectsPath());
   if (needInit) {
-    yield operator.traverseDependenciesToProject(
+    await operator.traverseDependenciesToProject(
       projectName,
-      (currentProject) => __async(void 0, null, function* () {
-        yield dependenciesTask(currentProject);
-      })
+      async (currentProject) => {
+        await dependenciesTask(currentProject);
+      }
     );
   }
-  yield new Promise((resolve) => {
+  await new Promise((resolve) => {
     console.info("start watch");
-    watcher.on("all", (eventName, changeFilePath) => __async(void 0, null, function* () {
+    watcher.on("all", async (eventName, changeFilePath) => {
       if (eventName === "add") {
         watchedProjectState.updateState();
       }
       const changedProject = watchedProjectState.getChangedProject(changeFilePath);
       if (changedProject) {
-        yield operator.traverseProjectToDependent(
+        await operator.traverseProjectToDependent(
           changedProject.name,
-          (currentProject, _, earlyFinish) => __async(void 0, null, function* () {
+          async (currentProject, _, earlyFinish) => {
             if (currentProject.name === projectName) {
               earlyFinish();
               return;
@@ -78,20 +58,20 @@ const runBuildWatchTask = (_0, _1, _2, ..._3) => __async(void 0, [_0, _1, _2, ..
               currentProject.name
             )) {
               console.info("run build", currentProject.name);
-              yield dependenciesTask(currentProject);
+              await dependenciesTask(currentProject);
             }
-          }),
+          },
           { withSelf: true }
         );
         resolve(null);
       } else {
         console.info("changed is not in monorepo manager");
       }
-    }));
+    });
     resolve(null);
   });
-  yield devTask(operator.getNodeData(projectName, { checkExist: true }));
-});
+  await devTask(operator.getNodeData(projectName, { checkExist: true }));
+};
 export {
   runBuildWatchTask
 };

package/dist/{js/modern → esm}/features/dev/watch-projects-state.js

@@ -1,22 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import * as path from "path";
 import { globby } from "@modern-js/utils";
 class WatchedProjectsState {
@@ -44,9 +25,10 @@ class WatchedProjectsState {
             node.extra.path
           );
         }
-        return __spreadProps(__spreadValues({}, ret), {
+        return {
+          ...ret,
           [node.extra.path]: node
-        });
+        };
       },
       {}
     );