@monorepolint/utils 0.6.0-alpha.1 → 0.6.0-alpha.3

package/build/js/index.js

@@ -1,149 +1,291 @@
-// src/getWorkspacePackageDirs.ts
-import { existsSync } from "fs";
-import * as glob from "glob";
-import * as path from "node:path";
-import * as fs from "node:fs";
-import * as readYamlFile from "read-yaml-file";
-import { findPackages } from "find-packages";
-async function findPNPMWorkspacePackages(workspaceRoot) {
-  workspaceRoot = fs.realpathSync(workspaceRoot);
-  const workspaceManifest = await readYamlFile.default(
-    path.join(workspaceRoot, "pnpm-workspace.yaml")
-  );
-  return findPackages(workspaceRoot, {
-    ignore: ["**/node_modules/**", "**/bower_components/**"],
-    includeRoot: true,
-    patterns: workspaceManifest.packages
-  });
+// src/nanosecondsToSanity.ts
+function nanosecondsToSanity(n, precision = 9) {
+  return n / BigInt(1e9) + "." + ("" + n % BigInt(1e9)).padStart(9, "0").substring(0, precision) + "s";
 }
-async function getWorkspacePackageDirs(host, workspaceDir, resolvePaths = false) {
-  const packageJson = host.readJson(path.join(workspaceDir, "package.json"));
-  const isPnpmWorkspace = host.exists(path.join(workspaceDir, "pnpm-workspace.yaml"));
-  if (isPnpmWorkspace) {
-    const workspacePackages = await findPNPMWorkspacePackages(workspaceDir);
-    if (workspacePackages.length === 0) {
-      throw new Error("Invalid workspaceDir: " + workspaceDir);
+
+// src/Table.ts
+var Table = class {
+  #rows = [];
+  #config;
+  #columnWidths = [];
+  #footer = [];
+  #footerRowConfig;
+  #totalWidth = 0;
+  constructor(config) {
+    this.#config = {
+      padding: 2,
+      ...config
+    };
+    this.#columnWidths.fill(0, 0, config.columns.length);
+    if (config.showFooter) {
+      this.#footerRowConfig = [];
+      for (const columnConfig of config.columns) {
+        if (columnConfig.footer === void 0) {
+          throw new Error("Must specify footer fields when showFooter is true");
+        } else if (typeof columnConfig.footer === "string") {
+          this.#footerRowConfig.push({
+            type: "string",
+            alignment: "left",
+            aggregate: "static",
+            value: columnConfig.footer
+          });
+        } else if ("value" in columnConfig.footer) {
+          this.#footerRowConfig.push({
+            type: "string",
+            alignment: "left",
+            ...columnConfig.footer
+          });
+        } else if ("aggregate" in columnConfig.footer) {
+          if (columnConfig.type !== "bigint") {
+            throw new Error("expecting bigint for aggregate");
+          }
+          this.#footerRowConfig.push({
+            type: columnConfig.type,
+            renderAs: columnConfig.renderAs,
+            precision: columnConfig.precision,
+            alignment: "right",
+            ...columnConfig.footer
+          });
+        }
+      }
     }
-    return workspacePackages.map((project) => project.dir).filter((d) => d !== workspaceDir);
   }
-  if (!packageJson.workspaces) {
-    throw new Error("Unsupported! Monorepo is not backed by either pnpm nor yarn workspaces.");
+  addRow(...data) {
+    this.#rows.push(data);
   }
-  const ret = [];
-  const packageGlobs = Array.isArray(packageJson.workspaces) ? packageJson.workspaces : packageJson.workspaces.packages || [];
-  for (const pattern of packageGlobs) {
-    for (const packagePath of glob.sync(pattern, { cwd: workspaceDir })) {
-      const packageJsonPath = path.join(workspaceDir, packagePath, "package.json");
-      if (existsSync(packageJsonPath)) {
-        if (resolvePaths === true) {
-          ret.push(path.resolve(path.join(workspaceDir, packagePath)));
-        } else {
-          ret.push(packagePath);
+  #sumColumn(c) {
+    let total = BigInt(0);
+    for (const row of this.#rows) {
+      total += row[c];
+    }
+    return total;
+  }
+  #updateFooterRow() {
+    const footerRowConfig = this.#footerRowConfig;
+    if (footerRowConfig) {
+      for (let c = 0; c < footerRowConfig.length; c++) {
+        const footerColConfig = footerRowConfig[c];
+        switch (footerColConfig.aggregate) {
+          case "sum":
+            this.#footer[c] = this.#sumColumn(c);
+            break;
+          case "average":
+            this.#footer[c] = this.#sumColumn(c) / BigInt(this.#rows.length);
+            break;
+          case "static":
+            this.#footer[c] = footerColConfig.value;
+            break;
         }
       }
     }
   }
-  return ret;
-}
-
-// src/mutateJson.ts
-function mutateJson(path4, host, mutator) {
-  let file = host.readJson(path4);
-  file = mutator(file);
-  host.writeJson(path4, file);
-}
-
-// src/findWorkspaceDir.ts
-import * as path2 from "path";
-import * as fs2 from "fs";
-import { findUp } from "find-up";
-async function findPnpmWorkspaceDir(cwd) {
-  const workspaceManifestLocation = await findUp("pnpm-workspace.yaml", {
-    cwd: await fs2.promises.realpath(cwd)
-  });
-  return workspaceManifestLocation && path2.dirname(workspaceManifestLocation);
-}
-async function findWorkspaceDir(host, dir) {
-  const maybePnpmWorkspaceDir = await findPnpmWorkspaceDir(dir);
-  if (maybePnpmWorkspaceDir != null) {
-    return maybePnpmWorkspaceDir;
+  #calculateColumnWidths() {
+    var _a;
+    this.#columnWidths.fill(0, 0, this.#config.columns.length);
+    for (let c = 0; c < this.#config.columns.length; c++) {
+      const colConfig = this.#config.columns[c];
+      this.#columnWidths[c] = Math.max(
+        (this.#config.columns[c].header ?? "").length,
+        ...this.#rows.map(
+          (a) => this.#getCellValueAsString(a[c], colConfig).length
+        ),
+        this.#footer && this.#footerRowConfig ? this.#getCellValueAsString(
+          ((_a = this.#footer) == null ? void 0 : _a[c]) ?? "",
+          this.#footerRowConfig[c]
+        ).length : 0
+      );
+    }
+    this.#totalWidth = 0;
+    for (const colWidth of this.#columnWidths) {
+      this.#totalWidth += colWidth;
+    }
+    this.#totalWidth += (this.#columnWidths.length - 1) * this.#config.padding;
   }
-  const packagePath = path2.join(dir, "package.json");
-  if (host.exists(packagePath)) {
-    const packageJson = host.readJson(packagePath);
-    if (packageJson.workspaces !== void 0) {
-      return dir;
+  #printSeparator(fillString) {
+    const paddingString = "".padStart(this.#config.padding, " ");
+    let hr2 = "";
+    for (let c = 0; c < this.#columnWidths.length; c++) {
+      hr2 += "".padStart(this.#columnWidths[c], fillString) + paddingString;
     }
+    hr2 = hr2.trimRight();
+    console.log(hr2);
   }
-  const nextDir = path2.normalize(path2.join(dir, ".."));
-  if (nextDir === dir) {
-    return void 0;
+  #printHeaderRow() {
+    if (this.#config.showHeader) {
+      const colConfigs = this.#config.columns;
+      const paddingString = "".padStart(this.#config.padding, " ");
+      let hr = "";
+      for (let c = 0; c < colConfigs.length; c++) {
+        const heading = colConfigs[c].header ?? "";
+        hr += heading.padEnd(this.#columnWidths[c], " ") + paddingString;
+      }
+      hr = hr.trimRight();
+      console.log(hr);
+      this.#printSeparator("-");
+    }
   }
-  return findWorkspaceDir(host, nextDir);
-}
-
-// src/getPackageNameToDir.ts
-import { join as pathJoin } from "path";
-async function getPackageNameToDir(host, workspaceDir, resolvePaths = false) {
-  const ret = /* @__PURE__ */ new Map();
-  const workspacePackages = await getWorkspacePackageDirs(host, workspaceDir, resolvePaths);
-  for (const packageDir of workspacePackages) {
-    const packagePath = pathJoin(packageDir, "package.json");
-    const { name } = host.readJson(packagePath);
-    if (name === void 0) {
-      throw new Error(`Package needs a name: ${packagePath}`);
+  #printFooterRow() {
+    const footerRow = this.#footer;
+    if (footerRow) {
+      this.#printSeparator("=");
+      const paddingString = "".padStart(this.#config.padding, " ");
+      let hr = "";
+      for (let c = 0; c < footerRow.length; c++) {
+        hr += this.#getCellValueAligned(footerRow[c], this.#footerRowConfig[c], c) + paddingString;
+      }
+      hr = hr.trimRight();
+      console.log(hr);
     }
-    ret.set(name, packageDir);
   }
-  return ret;
-}
-
-// src/SimpleHost.ts
-import * as realFs from "fs";
-var SimpleHost = class {
-  constructor(fs3 = realFs) {
-    this.fs = fs3;
+  print() {
+    if (this.#config.sortColumn !== void 0) {
+    }
+    this.#updateFooterRow();
+    this.#calculateColumnWidths();
+    console.log();
+    console.log(`${this.#config.title}`);
+    console.log("".padStart(this.#totalWidth, "="));
+    const paddingString = "".padStart(this.#config.padding, " ");
+    if (this.#config.showHeader) {
+      this.#printHeaderRow();
+    }
+    for (let r = 0; r < this.#rows.length; r++) {
+      let rowText = "";
+      for (let c = 0; c < this.#config.columns.length; c++) {
+        rowText += this.getEntryAsStringAligned(c, r) + paddingString;
+      }
+      rowText.trim();
+      console.log(rowText);
+    }
+    if (this.#config.showFooter) this.#printFooterRow();
+    console.log();
   }
-  mkdir(directoryPath, opts) {
-    this.fs.mkdirSync(directoryPath, { recursive: (opts == null ? void 0 : opts.recursive) ?? false });
+  #getCellValueAsString(value, config) {
+    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
+      return nanosecondsToSanity(value, config.precision ?? 9);
+    } else {
+      return "" + value;
+    }
   }
-  rmdir(directoryPath) {
-    this.fs.rmdirSync(directoryPath);
+  #getCellValueAligned(value, config, column) {
+    let result;
+    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
+      result = nanosecondsToSanity(value, config.precision ?? 9);
+    } else {
+      result = "" + value;
+    }
+    if (config.alignment === "left") {
+      return result.padEnd(this.#columnWidths[column]);
+    } else {
+      return result.padStart(this.#columnWidths[column]);
+    }
   }
-  exists(path4) {
-    return this.fs.existsSync(path4);
+  getEntryAsString(colNum, rowNum) {
+    const config = this.#config.columns[colNum];
+    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
+      return nanosecondsToSanity(
+        this.#rows[rowNum][colNum],
+        config.precision ?? 9
+      );
+    } else {
+      return "" + this.#rows[rowNum][colNum];
+    }
   }
-  writeFile(path4, body, opts) {
-    if (opts) {
-      this.fs.writeFileSync(path4, body, { encoding: opts.encoding });
+  getEntryAsStringAligned(colNum, rowNum) {
+    const config = this.#config.columns[colNum];
+    let result;
+    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
+      result = nanosecondsToSanity(
+        this.#rows[rowNum][colNum],
+        config.precision ?? 9
+      );
     } else {
-      this.fs.writeFileSync(path4, body);
+      result = "" + this.#rows[rowNum][colNum];
+    }
+    if (config.alignment === "left") {
+      return result.padEnd(this.#columnWidths[colNum]);
+    } else {
+      return result.padStart(this.#columnWidths[colNum]);
     }
   }
-  readFile(path4, opts) {
-    if (opts == null ? void 0 : opts.asJson) {
-      return JSON.parse(this.fs.readFileSync(path4, "utf-8"));
+  getColumnWidth(colNum, config) {
+    let maxWidth = Math.max(
+      (config.header ?? "").length,
+      this.#footer && this.#footerRowConfig ? this.#getCellValueAsString(
+        this.#footer[colNum],
+        this.#footerRowConfig[colNum]
+      ).length : 0
+    );
+    for (let r = 0; r < this.#rows.length; r++) {
+      maxWidth = Math.max(maxWidth, this.getEntryAsString(colNum, r).length);
     }
-    return this.fs.readFileSync(path4, opts == null ? void 0 : opts.encoding);
+    return maxWidth;
   }
-  deleteFile(path4) {
-    this.fs.unlinkSync(path4);
+};
+
+// src/AggregateTiming.ts
+var AggregateTiming = class {
+  constructor(title) {
+    this.title = title;
   }
-  readJson(filename) {
-    const contents = this.fs.readFileSync(filename, "utf-8");
-    return JSON.parse(contents);
+  #data = /* @__PURE__ */ new Map();
+  #last;
+  start(name) {
+    const time = process.hrtime.bigint();
+    if (this.#last) {
+      this.#last.total += time;
+    }
+    let data = this.#data.get(name);
+    if (data === void 0) {
+      data = { count: 1, total: -time };
+      this.#data.set(name, data);
+    } else {
+      data.total -= time;
+      data.count++;
+    }
+    this.#last = data;
   }
-  writeJson(path4, o) {
-    return this.fs.writeFileSync(path4, JSON.stringify(o, void 0, 2) + "\n");
+  stop() {
+    const time = process.hrtime.bigint();
+    if (this.#last) {
+      this.#last.total += time;
+      this.#last = void 0;
+    }
   }
-  flush() {
-    return Promise.resolve();
+  printResults() {
+    const table = new Table({
+      sortColumn: -1,
+      showFooter: true,
+      showHeader: true,
+      title: this.title,
+      columns: [
+        {
+          header: "Duration",
+          type: "bigint",
+          renderAs: "nanoseconds",
+          footer: { aggregate: "sum" }
+        },
+        { header: "Task", type: "string", alignment: "left", footer: "TOTAL" },
+        { header: "Count", type: "bigint", footer: { aggregate: "sum" } },
+        { header: "Avg", type: "bigint", footer: { aggregate: "average" } }
+      ]
+    });
+    for (const [name, value] of this.#data) {
+      table.addRow(
+        value.total,
+        name,
+        BigInt(value.count),
+        // fixme this can be a number later
+        value.total / BigInt(value.count)
+      );
+    }
+    table.print();
   }
 };
 
 // src/CachingHost.ts
-import * as realFs2 from "node:fs";
-import * as path3 from "node:path";
+import * as realFs from "node:fs";
+import * as path from "node:path";
 function assertNoTombstone(node) {
   if (node.tombstone) {
     throw new Error(`Unexpected tombstone ${JSON.stringify(node)}`);
@@ -170,33 +312,34 @@ function assertHasParent(node) {
   }
 }
 var CachingHost = class {
-  constructor(fs3 = realFs2) {
+  constructor(fs3 = realFs) {
     this.fs = fs3;
   }
   // We need many trees because of windows, key is the `root`
   #trees = /* @__PURE__ */ new Map();
   #replaceNode(node, partialNewNode) {
-    if (!node.parent)
-      throw new Error("Cannot replace root node");
+    if (!node.parent) throw new Error("Cannot replace root node");
     const newNode = {
       ...partialNewNode,
       fullPath: node.fullPath,
       parent: node.parent,
       dir: node.dir
     };
-    node.parent.dir.set(path3.basename(node.fullPath), newNode);
+    node.parent.dir.set(path.basename(node.fullPath), newNode);
     return newNode;
   }
   #unstubDirectory(node) {
     for (const child of this.fs.readdirSync(node.fullPath)) {
-      this.#getNode(path3.join(node.fullPath, child));
+      this.#getNode(path.join(node.fullPath, child));
     }
     node.stub = false;
   }
   #stubify(filePath, parent) {
-    const canonicalPath = path3.resolve(filePath);
-    if (!parent && canonicalPath !== path3.parse(canonicalPath).root) {
-      throw new Error(`parent can only be null if path is root. Instead got: ${canonicalPath}`);
+    const canonicalPath = path.resolve(filePath);
+    if (!parent && canonicalPath !== path.parse(canonicalPath).root) {
+      throw new Error(
+        `parent can only be null if path is root. Instead got: ${canonicalPath}`
+      );
     }
     const stat = this.fs.lstatSync(canonicalPath);
     let node;
@@ -226,15 +369,19 @@ var CachingHost = class {
         needsFlush: false
       };
     } else {
-      throw new Error(`what is not a file nor symlink nor directory? nothing we care about: ${canonicalPath}`);
+      throw new Error(
+        `what is not a file nor symlink nor directory? nothing we care about: ${canonicalPath}`
+      );
     }
     if (!parent && node.type === "dir") {
       this.#trees.set(canonicalPath, node);
       return node;
     } else if (parent) {
-      parent.dir.set(path3.basename(canonicalPath), node);
+      parent.dir.set(path.basename(canonicalPath), node);
     } else {
-      throw new Error(`root can only be a dir, got ${JSON.stringify(node)} for path: ${canonicalPath}`);
+      throw new Error(
+        `root can only be a dir, got ${JSON.stringify(node)} for path: ${canonicalPath}`
+      );
     }
     return node;
   }
@@ -243,13 +390,13 @@ var CachingHost = class {
    * You should check the `fullPath` of the result.
    */
   #getNearestAncestorNode(filePath) {
-    const canonicalPath = path3.resolve(filePath);
-    const { root } = path3.parse(canonicalPath);
+    const canonicalPath = path.resolve(filePath);
+    const { root } = path.parse(canonicalPath);
     const parts = [];
     let maybePath = canonicalPath;
     while (maybePath !== root) {
-      parts.unshift(path3.basename(maybePath));
-      maybePath = path3.dirname(maybePath);
+      parts.unshift(path.basename(maybePath));
+      maybePath = path.dirname(maybePath);
     }
     let curPath = root;
     let curNode = this.#trees.get(root) ?? this.#stubify(curPath, void 0);
@@ -258,7 +405,9 @@ var CachingHost = class {
         assertNoTombstone(curNode);
         assertNotType(curNode, "file");
         if (curNode.type === "symlink") {
-          const linkedNode = this.#getNodeResolvingSymlinks(path3.resolve(path3.dirname(curPath), curNode.symlink));
+          const linkedNode = this.#getNodeResolvingSymlinks(
+            path.resolve(path.dirname(curPath), curNode.symlink)
+          );
           assertExists(linkedNode);
           assertNoTombstone(linkedNode);
           assertType(linkedNode, "dir");
@@ -266,16 +415,18 @@ var CachingHost = class {
         }
         assertType(curNode, "dir");
         assertNoTombstone(curNode);
-        curNode = curNode.dir.get(part) ?? this.#stubify(path3.join(curNode.fullPath, part), curNode);
-        curPath = path3.join(curPath, part);
+        curNode = curNode.dir.get(part) ?? this.#stubify(path.join(curNode.fullPath, part), curNode);
+        curPath = path.join(curPath, part);
       }
     } catch (e) {
     }
     return { pathWithSymlinks: curPath, node: curNode };
   }
   #getNode(filePath) {
-    const canonicalPath = path3.resolve(filePath);
-    const { pathWithSymlinks, node } = this.#getNearestAncestorNode(canonicalPath);
+    const canonicalPath = path.resolve(filePath);
+    const { pathWithSymlinks, node } = this.#getNearestAncestorNode(
+      canonicalPath
+    );
     if (pathWithSymlinks === canonicalPath) {
       return node;
     }
@@ -283,24 +434,23 @@ var CachingHost = class {
   }
   #getNodeResolvingSymlinks(filePath, follows = 100) {
     const node = this.#getNode(filePath);
-    if (!node || node.type !== "symlink")
-      return node;
-    if (follows === 0)
-      throw new Error("Exhausted symlink follows");
+    if (!node || node.type !== "symlink") return node;
+    if (follows === 0) throw new Error("Exhausted symlink follows");
     return this.#getNodeResolvingSymlinks(node.symlink, follows--);
   }
   mkdir(filePath, opts = { recursive: false }) {
-    const canonicalPath = path3.resolve(filePath);
-    const { node, pathWithSymlinks } = this.#getNearestAncestorNode(canonicalPath);
+    const canonicalPath = path.resolve(filePath);
+    const { node, pathWithSymlinks } = this.#getNearestAncestorNode(
+      canonicalPath
+    );
     if (filePath === pathWithSymlinks) {
       assertType(node, "dir");
       assertHasParent(node);
-      if (!node.tombstone)
-        return;
-    } else if (path3.dirname(filePath) === pathWithSymlinks) {
+      if (!node.tombstone) return;
+    } else if (path.dirname(filePath) === pathWithSymlinks) {
       assertType(node, "dir");
       assertNoTombstone(node);
-      node.dir.set(path3.basename(filePath), {
+      node.dir.set(path.basename(filePath), {
         type: "dir",
         fullPath: filePath,
         parent: node,
@@ -309,15 +459,17 @@ var CachingHost = class {
       });
       return;
     }
-    if (!opts.recursive && path3.dirname(canonicalPath) !== pathWithSymlinks) {
+    if (!opts.recursive && path.dirname(canonicalPath) !== pathWithSymlinks) {
       throw new Error("no such file or directory");
     }
     const rootPath = pathWithSymlinks;
     let maybePath = canonicalPath;
     const toMake = [];
     while (maybePath !== rootPath) {
-      toMake.unshift(path3.resolve(node.fullPath, path3.relative(rootPath, maybePath)));
-      maybePath = path3.dirname(maybePath);
+      toMake.unshift(
+        path.resolve(node.fullPath, path.relative(rootPath, maybePath))
+      );
+      maybePath = path.dirname(maybePath);
     }
     for (const dirToMake of toMake) {
       this.mkdir(dirToMake);
@@ -370,7 +522,7 @@ var CachingHost = class {
   }
   writeFile(filePath, body, opts) {
     const fileContentsAsBuffer = typeof body === "string" ? Buffer.from(body, opts == null ? void 0 : opts.encoding) : Buffer.from(body);
-    const canonicalPath = path3.resolve(filePath);
+    const canonicalPath = path.resolve(filePath);
     const existingNode = this.#getNodeResolvingSymlinks(canonicalPath);
     if (existingNode) {
       if (existingNode.type === "dir") {
@@ -383,11 +535,13 @@ var CachingHost = class {
       });
       return;
     }
-    const maybeDirNode = this.#getNodeResolvingSymlinks(path3.dirname(canonicalPath));
+    const maybeDirNode = this.#getNodeResolvingSymlinks(
+      path.dirname(canonicalPath)
+    );
     assertExists(maybeDirNode);
     assertType(maybeDirNode, "dir");
     assertNoTombstone(maybeDirNode);
-    maybeDirNode.dir.set(path3.basename(canonicalPath), {
+    maybeDirNode.dir.set(path.basename(canonicalPath), {
       type: "file",
       fullPath: canonicalPath,
       parent: maybeDirNode,
@@ -396,10 +550,9 @@ var CachingHost = class {
     });
   }
   deleteFile(filePath) {
-    const canonicalPath = path3.resolve(filePath);
+    const canonicalPath = path.resolve(filePath);
     const node = this.#getNode(canonicalPath);
-    if (!node || node.type === "file" && node.tombstone === true)
-      return;
+    if (!node || node.type === "file" && node.tombstone === true) return;
     assertNotType(node, "dir");
     this.#replaceNode(node, {
       type: "file",
@@ -426,274 +579,173 @@ var CachingHost = class {
     } else if (node.stub === true || node.needsFlush === false) {
       return;
     } else {
-      return this.fs.promises.writeFile(node.fullPath, node.file);
-    }
-  }
-  async #flushSymlinkNode(node) {
-    if (!node.needsFlush)
-      return;
-    try {
-      const linkValue = await this.fs.promises.readlink(node.fullPath);
-      if (linkValue === node.symlink) {
-        return;
-      }
-    } catch (e) {
-    }
-    return this.fs.promises.symlink(node.symlink, node.fullPath);
-  }
-  async #flushDirNode(node) {
-    if (!node.tombstone && node.needsFlush) {
-      try {
-        await this.fs.promises.access(node.fullPath);
-      } catch (e) {
-        await this.fs.promises.mkdir(node.fullPath);
-      }
-    }
-    const promises2 = [];
-    for (const child of node.dir.values()) {
-      if (node.tombstone && !child.tombstone) {
-        throw new Error("Unexpected failure during sanity check. A non-deleted child is on a deleted dir");
-      }
-      if (child.type === "dir") {
-        promises2.push(this.#flushDirNode(child));
-      } else if (child.type === "file") {
-        promises2.push(this.#flushFileNode(child));
-      } else if (child.type === "symlink") {
-        promises2.push(this.#flushSymlinkNode(child));
-      } else {
-        throw new Error("should never happen");
-      }
-    }
-    await Promise.all(promises2);
-    if (node.tombstone) {
-      return this.fs.promises.rmdir(node.fullPath);
-    }
-    return;
-  }
-  flush() {
-    const promises2 = [];
-    for (const rootNode of this.#trees.values()) {
-      promises2.push(this.#flushDirNode(rootNode));
-    }
-    return Promise.all(promises2);
-  }
-};
-
-// src/matchesAnyGlob.ts
-import micromatch from "micromatch";
-
-// src/nanosecondsToSanity.ts
-function nanosecondsToSanity(n, precision = 9) {
-  return n / BigInt(1e9) + "." + ("" + n % BigInt(1e9)).padStart(9, "0").substring(0, precision) + "s";
-}
-
-// src/Table.ts
-var Table = class {
-  #rows = [];
-  #config;
-  #columnWidths = [];
-  #footer = [];
-  #footerRowConfig;
-  #totalWidth = 0;
-  constructor(config) {
-    this.#config = {
-      padding: 2,
-      ...config
-    };
-    this.#columnWidths.fill(0, 0, config.columns.length);
-    if (config.showFooter) {
-      this.#footerRowConfig = [];
-      for (const columnConfig of config.columns) {
-        if (columnConfig.footer === void 0) {
-          throw new Error("Must specify footer fields when showFooter is true");
-        } else if (typeof columnConfig.footer === "string") {
-          this.#footerRowConfig.push({
-            type: "string",
-            alignment: "left",
-            aggregate: "static",
-            value: columnConfig.footer
-          });
-        } else if ("value" in columnConfig.footer) {
-          this.#footerRowConfig.push({
-            type: "string",
-            alignment: "left",
-            ...columnConfig.footer
-          });
-        } else if ("aggregate" in columnConfig.footer) {
-          if (columnConfig.type !== "bigint")
-            throw new Error("expecting bigint for aggregate");
-          this.#footerRowConfig.push({
-            type: columnConfig.type,
-            renderAs: columnConfig.renderAs,
-            precision: columnConfig.precision,
-            alignment: "right",
-            ...columnConfig.footer
-          });
-        }
-      }
-    }
-  }
-  addRow(...data) {
-    this.#rows.push(data);
-  }
-  #sumColumn(c) {
-    let total = BigInt(0);
-    for (const row of this.#rows) {
-      total += row[c];
-    }
-    return total;
-  }
-  #updateFooterRow() {
-    const footerRowConfig = this.#footerRowConfig;
-    if (footerRowConfig) {
-      for (let c = 0; c < footerRowConfig.length; c++) {
-        const footerColConfig = footerRowConfig[c];
-        switch (footerColConfig.aggregate) {
-          case "sum":
-            this.#footer[c] = this.#sumColumn(c);
-            break;
-          case "average":
-            this.#footer[c] = this.#sumColumn(c) / BigInt(this.#rows.length);
-            break;
-          case "static":
-            this.#footer[c] = footerColConfig.value;
-            break;
-        }
-      }
-    }
-  }
-  #calculateColumnWidths() {
-    var _a;
-    this.#columnWidths.fill(0, 0, this.#config.columns.length);
-    for (let c = 0; c < this.#config.columns.length; c++) {
-      const colConfig = this.#config.columns[c];
-      this.#columnWidths[c] = Math.max(
-        (this.#config.columns[c].header ?? "").length,
-        ...this.#rows.map((a) => this.#getCellValueAsString(a[c], colConfig).length),
-        this.#footer && this.#footerRowConfig ? this.#getCellValueAsString(((_a = this.#footer) == null ? void 0 : _a[c]) ?? "", this.#footerRowConfig[c]).length : 0
-      );
-    }
-    this.#totalWidth = 0;
-    for (const colWidth of this.#columnWidths) {
-      this.#totalWidth += colWidth;
-    }
-    this.#totalWidth += (this.#columnWidths.length - 1) * this.#config.padding;
-  }
-  #printSeparator(fillString) {
-    const paddingString = "".padStart(this.#config.padding, " ");
-    let hr2 = "";
-    for (let c = 0; c < this.#columnWidths.length; c++) {
-      hr2 += "".padStart(this.#columnWidths[c], fillString) + paddingString;
-    }
-    hr2 = hr2.trimRight();
-    console.log(hr2);
-  }
-  #printHeaderRow() {
-    if (this.#config.showHeader) {
-      const colConfigs = this.#config.columns;
-      const paddingString = "".padStart(this.#config.padding, " ");
-      let hr = "";
-      for (let c = 0; c < colConfigs.length; c++) {
-        const heading = colConfigs[c].header ?? "";
-        hr += heading.padEnd(this.#columnWidths[c], " ") + paddingString;
-      }
-      hr = hr.trimRight();
-      console.log(hr);
-      this.#printSeparator("-");
-    }
-  }
-  #printFooterRow() {
-    const footerRow = this.#footer;
-    if (footerRow) {
-      this.#printSeparator("=");
-      const paddingString = "".padStart(this.#config.padding, " ");
-      let hr = "";
-      for (let c = 0; c < footerRow.length; c++) {
-        hr += this.#getCellValueAligned(footerRow[c], this.#footerRowConfig[c], c) + paddingString;
-      }
-      hr = hr.trimRight();
-      console.log(hr);
-    }
-  }
-  print() {
-    if (this.#config.sortColumn !== void 0) {
-    }
-    this.#updateFooterRow();
-    this.#calculateColumnWidths();
-    console.log();
-    console.log(`${this.#config.title}`);
-    console.log("".padStart(this.#totalWidth, "="));
-    const paddingString = "".padStart(this.#config.padding, " ");
-    if (this.#config.showHeader) {
-      this.#printHeaderRow();
-    }
-    for (let r = 0; r < this.#rows.length; r++) {
-      let rowText = "";
-      for (let c = 0; c < this.#config.columns.length; c++) {
-        rowText += this.getEntryAsStringAligned(c, r) + paddingString;
-      }
-      rowText.trim();
-      console.log(rowText);
+      return this.fs.promises.writeFile(node.fullPath, node.file);
     }
-    if (this.#config.showFooter)
-      this.#printFooterRow();
-    console.log();
   }
-  #getCellValueAsString(value, config) {
-    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
-      return nanosecondsToSanity(value, config.precision ?? 9);
-    } else {
-      return "" + value;
+  async #flushSymlinkNode(node) {
+    if (!node.needsFlush) return;
+    try {
+      const linkValue = await this.fs.promises.readlink(node.fullPath);
+      if (linkValue === node.symlink) {
+        return;
+      }
+    } catch (e) {
     }
+    return this.fs.promises.symlink(node.symlink, node.fullPath);
   }
-  #getCellValueAligned(value, config, column) {
-    let result;
-    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
-      result = nanosecondsToSanity(value, config.precision ?? 9);
-    } else {
-      result = "" + value;
+  async #flushDirNode(node) {
+    if (!node.tombstone && node.needsFlush) {
+      try {
+        await this.fs.promises.access(node.fullPath);
+      } catch (e) {
+        await this.fs.promises.mkdir(node.fullPath);
+      }
     }
-    if (config.alignment === "left") {
-      return result.padEnd(this.#columnWidths[column]);
-    } else {
-      return result.padStart(this.#columnWidths[column]);
+    const promises2 = [];
+    for (const child of node.dir.values()) {
+      if (node.tombstone && !child.tombstone) {
+        throw new Error(
+          "Unexpected failure during sanity check. A non-deleted child is on a deleted dir"
+        );
+      }
+      if (child.type === "dir") {
+        promises2.push(this.#flushDirNode(child));
+      } else if (child.type === "file") {
+        promises2.push(this.#flushFileNode(child));
+      } else if (child.type === "symlink") {
+        promises2.push(this.#flushSymlinkNode(child));
+      } else {
+        throw new Error("should never happen");
+      }
+    }
+    await Promise.all(promises2);
+    if (node.tombstone) {
+      return this.fs.promises.rmdir(node.fullPath);
     }
+    return;
   }
-  getEntryAsString(colNum, rowNum) {
-    const config = this.#config.columns[colNum];
-    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
-      return nanosecondsToSanity(this.#rows[rowNum][colNum], config.precision ?? 9);
-    } else {
-      return "" + this.#rows[rowNum][colNum];
+  flush() {
+    const promises2 = [];
+    for (const rootNode of this.#trees.values()) {
+      promises2.push(this.#flushDirNode(rootNode));
     }
+    return Promise.all(promises2);
   }
-  getEntryAsStringAligned(colNum, rowNum) {
-    const config = this.#config.columns[colNum];
-    let result;
-    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
-      result = nanosecondsToSanity(this.#rows[rowNum][colNum], config.precision ?? 9);
-    } else {
-      result = "" + this.#rows[rowNum][colNum];
+};
+
+// src/findWorkspaceDir.ts
+import { findUp } from "find-up";
+import * as fs from "fs";
+import * as path2 from "path";
+async function findPnpmWorkspaceDir(cwd) {
+  const workspaceManifestLocation = await findUp("pnpm-workspace.yaml", {
+    cwd: await fs.promises.realpath(cwd)
+  });
+  return workspaceManifestLocation && path2.dirname(workspaceManifestLocation);
+}
+async function findWorkspaceDir(host, dir) {
+  const maybePnpmWorkspaceDir = await findPnpmWorkspaceDir(dir);
+  if (maybePnpmWorkspaceDir != null) {
+    return maybePnpmWorkspaceDir;
+  }
+  const packagePath = path2.join(dir, "package.json");
+  if (host.exists(packagePath)) {
+    const packageJson = host.readJson(packagePath);
+    if (packageJson.workspaces !== void 0) {
+      return dir;
     }
-    if (config.alignment === "left") {
-      return result.padEnd(this.#columnWidths[colNum]);
-    } else {
-      return result.padStart(this.#columnWidths[colNum]);
+  }
+  const nextDir = path2.normalize(path2.join(dir, ".."));
+  if (nextDir === dir) {
+    return void 0;
+  }
+  return findWorkspaceDir(host, nextDir);
+}
+
+// src/getPackageNameToDir.ts
+import { join as pathJoin } from "path";
+
+// src/getWorkspacePackageDirs.ts
+import { findPackages } from "find-packages";
+import { existsSync } from "fs";
+import * as glob from "glob";
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import readYamlFile from "read-yaml-file";
+async function findPNPMWorkspacePackages(workspaceRoot) {
+  workspaceRoot = fs2.realpathSync(workspaceRoot);
+  const workspaceManifest = await readYamlFile.default(
+    path3.join(workspaceRoot, "pnpm-workspace.yaml")
+  );
+  return findPackages(workspaceRoot, {
+    ignore: ["**/node_modules/**", "**/bower_components/**"],
+    includeRoot: true,
+    patterns: workspaceManifest.packages
+  });
+}
+async function getWorkspacePackageDirs(host, workspaceDir, resolvePaths = false) {
+  const packageJson = host.readJson(
+    path3.join(workspaceDir, "package.json")
+  );
+  const isPnpmWorkspace = host.exists(
+    path3.join(workspaceDir, "pnpm-workspace.yaml")
+  );
+  if (isPnpmWorkspace) {
+    const workspacePackages = await findPNPMWorkspacePackages(workspaceDir);
+    if (workspacePackages.length === 0) {
+      throw new Error("Invalid workspaceDir: " + workspaceDir);
     }
+    return workspacePackages.map((project) => project.dir).filter(
+      (d) => d !== workspaceDir
+    );
   }
-  getColumnWidth(colNum, config) {
-    let maxWidth = Math.max(
-      (config.header ?? "").length,
-      this.#footer && this.#footerRowConfig ? this.#getCellValueAsString(this.#footer[colNum], this.#footerRowConfig[colNum]).length : 0
+  if (!packageJson.workspaces) {
+    throw new Error(
+      "Unsupported! Monorepo is not backed by either pnpm nor yarn workspaces."
     );
-    for (let r = 0; r < this.#rows.length; r++) {
-      maxWidth = Math.max(maxWidth, this.getEntryAsString(colNum, r).length);
+  }
+  const ret = [];
+  const packageGlobs = Array.isArray(packageJson.workspaces) ? packageJson.workspaces : packageJson.workspaces.packages || [];
+  for (const pattern of packageGlobs) {
+    for (const packagePath of glob.sync(pattern, { cwd: workspaceDir })) {
+      const packageJsonPath = path3.join(
+        workspaceDir,
+        packagePath,
+        "package.json"
+      );
+      if (existsSync(packageJsonPath)) {
+        if (resolvePaths === true) {
+          ret.push(path3.resolve(path3.join(workspaceDir, packagePath)));
+        } else {
+          ret.push(packagePath);
+        }
+      }
     }
-    return maxWidth;
   }
-};
+  return ret;
+}
+
+// src/getPackageNameToDir.ts
+async function getPackageNameToDir(host, workspaceDir, resolvePaths = false) {
+  const ret = /* @__PURE__ */ new Map();
+  const workspacePackages = await getWorkspacePackageDirs(
+    host,
+    workspaceDir,
+    resolvePaths
+  );
+  for (const packageDir of workspacePackages) {
+    const packagePath = pathJoin(packageDir, "package.json");
+    const { name } = host.readJson(packagePath);
+    if (name === void 0) {
+      throw new Error(`Package needs a name: ${packagePath}`);
+    }
+    ret.set(name, packageDir);
+  }
+  return ret;
+}
 
 // src/matchesAnyGlob.ts
+import micromatch from "micromatch";
 var cache = /* @__PURE__ */ new Map();
 var singleMatcherCache = /* @__PURE__ */ new Map();
 var compiledGlobCache = /* @__PURE__ */ new Map();
@@ -734,8 +786,7 @@ var matchesAnyGlob = function matchesAnyGlobFunc(needle, haystack) {
         singleMatcherHits++;
         singleMatcherSaves++;
       }
-      if (result)
-        break;
+      if (result) break;
     }
     cacheForHaystack.set(needle, result);
   } else {
@@ -764,63 +815,53 @@ matchesAnyGlob.printStats = () => {
   table.print();
 };
 
-// src/AggregateTiming.ts
-var AggregateTiming = class {
-  constructor(title) {
-    this.title = title;
+// src/mutateJson.ts
+function mutateJson(path4, host, mutator) {
+  let file = host.readJson(path4);
+  file = mutator(file);
+  host.writeJson(path4, file);
+}
+
+// src/SimpleHost.ts
+import * as realFs2 from "fs";
+var SimpleHost = class {
+  constructor(fs3 = realFs2) {
+    this.fs = fs3;
   }
-  #data = /* @__PURE__ */ new Map();
-  #last;
-  start(name) {
-    const time = process.hrtime.bigint();
-    if (this.#last) {
-      this.#last.total += time;
-    }
-    let data = this.#data.get(name);
-    if (data === void 0) {
-      data = { count: 1, total: -time };
-      this.#data.set(name, data);
+  mkdir(directoryPath, opts) {
+    this.fs.mkdirSync(directoryPath, { recursive: (opts == null ? void 0 : opts.recursive) ?? false });
+  }
+  rmdir(directoryPath) {
+    this.fs.rmdirSync(directoryPath);
+  }
+  exists(path4) {
+    return this.fs.existsSync(path4);
+  }
+  writeFile(path4, body, opts) {
+    if (opts) {
+      this.fs.writeFileSync(path4, body, { encoding: opts.encoding });
     } else {
-      data.total -= time;
-      data.count++;
+      this.fs.writeFileSync(path4, body);
     }
-    this.#last = data;
   }
-  stop() {
-    const time = process.hrtime.bigint();
-    if (this.#last) {
-      this.#last.total += time;
-      this.#last = void 0;
+  readFile(path4, opts) {
+    if (opts == null ? void 0 : opts.asJson) {
+      return JSON.parse(this.fs.readFileSync(path4, "utf-8"));
     }
+    return this.fs.readFileSync(path4, opts == null ? void 0 : opts.encoding);
   }
-  printResults() {
-    const table = new Table({
-      sortColumn: -1,
-      showFooter: true,
-      showHeader: true,
-      title: this.title,
-      columns: [
-        {
-          header: "Duration",
-          type: "bigint",
-          renderAs: "nanoseconds",
-          footer: { aggregate: "sum" }
-        },
-        { header: "Task", type: "string", alignment: "left", footer: "TOTAL" },
-        { header: "Count", type: "bigint", footer: { aggregate: "sum" } },
-        { header: "Avg", type: "bigint", footer: { aggregate: "average" } }
-      ]
-    });
-    for (const [name, value] of this.#data) {
-      table.addRow(
-        value.total,
-        name,
-        BigInt(value.count),
-        // fixme this can be a number later
-        value.total / BigInt(value.count)
-      );
-    }
-    table.print();
+  deleteFile(path4) {
+    this.fs.unlinkSync(path4);
+  }
+  readJson(filename) {
+    const contents = this.fs.readFileSync(filename, "utf-8");
+    return JSON.parse(contents);
+  }
+  writeJson(path4, o) {
+    return this.fs.writeFileSync(path4, JSON.stringify(o, void 0, 2) + "\n");
+  }
+  flush() {
+    return Promise.resolve();
   }
 };
 
@@ -880,13 +921,13 @@ export {
   nanosecondsToSanity
 };
 /*!
- * Copyright 2019 Palantir Technologies, Inc.
+ * Copyright 2022 Palantir Technologies, Inc.
  *
  * Licensed under the MIT license. See LICENSE file in the project root for details.
  *
  */
 /*!
- * Copyright 2022 Palantir Technologies, Inc.
+ * Copyright 2019 Palantir Technologies, Inc.
  *
  * Licensed under the MIT license. See LICENSE file in the project root for details.
  *