@monorepolint/utils 0.5.0-beta.7 → 0.5.0-beta.9

package/build/js/index.js

@@ -0,0 +1,894 @@
+// 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
+  });
+}
+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);
+    }
+    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.");
+  }
+  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);
+        }
+      }
+    }
+  }
+  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;
+  }
+  const packagePath = path2.join(dir, "package.json");
+  if (host.exists(packagePath)) {
+    const packageJson = host.readJson(packagePath);
+    if (packageJson.workspaces !== void 0) {
+      return dir;
+    }
+  }
+  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";
+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/SimpleHost.ts
+import * as realFs from "fs";
+var SimpleHost = class {
+  constructor(fs3 = realFs) {
+    this.fs = fs3;
+  }
+  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 {
+      this.fs.writeFileSync(path4, body);
+    }
+  }
+  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);
+  }
+  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();
+  }
+};
+
+// src/CachingHost.ts
+import * as realFs2 from "node:fs";
+import * as path3 from "node:path";
+function assertNoTombstone(node) {
+  if (node.tombstone) {
+    throw new Error(`Unexpected tombstone ${JSON.stringify(node)}`);
+  }
+}
+function assertNotType(node, type) {
+  if (node.type === type) {
+    throw new Error(`Unexpected node type ${JSON.stringify(node)}`);
+  }
+}
+function assertType(node, type) {
+  if (node.type !== type) {
+    throw new Error(`Unexpected node type ${JSON.stringify(node)}`);
+  }
+}
+function assertExists(node) {
+  if (!node) {
+    throw new Error(`Expected node to exist`);
+  }
+}
+function assertHasParent(node) {
+  if (!node.parent) {
+    throw new Error("Expected node to have a parent directory");
+  }
+}
+var CachingHost = class {
+  constructor(fs3 = realFs2) {
+    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");
+    const newNode = {
+      ...partialNewNode,
+      fullPath: node.fullPath,
+      parent: node.parent,
+      dir: node.dir
+    };
+    node.parent.dir.set(path3.basename(node.fullPath), newNode);
+    return newNode;
+  }
+  #unstubDirectory(node) {
+    for (const child of this.fs.readdirSync(node.fullPath)) {
+      this.#getNode(path3.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 stat = this.fs.lstatSync(canonicalPath);
+    let node;
+    if (stat.isDirectory()) {
+      node = {
+        fullPath: canonicalPath,
+        type: "dir",
+        stub: true,
+        dir: /* @__PURE__ */ new Map(),
+        parent,
+        needsFlush: false
+      };
+    } else if (stat.isSymbolicLink()) {
+      node = {
+        fullPath: canonicalPath,
+        type: "symlink",
+        symlink: this.fs.readlinkSync(canonicalPath),
+        parent,
+        needsFlush: false
+      };
+    } else if (stat.isFile()) {
+      node = {
+        fullPath: canonicalPath,
+        type: "file",
+        stub: true,
+        parent,
+        needsFlush: false
+      };
+    } else {
+      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);
+    } else {
+      throw new Error(`root can only be a dir, got ${JSON.stringify(node)} for path: ${canonicalPath}`);
+    }
+    return node;
+  }
+  /**
+   * Note: may return the node itself!
+   * You should check the `fullPath` of the result.
+   */
+  #getNearestAncestorNode(filePath) {
+    const canonicalPath = path3.resolve(filePath);
+    const { root } = path3.parse(canonicalPath);
+    const parts = [];
+    let maybePath = canonicalPath;
+    while (maybePath !== root) {
+      parts.unshift(path3.basename(maybePath));
+      maybePath = path3.dirname(maybePath);
+    }
+    let curPath = root;
+    let curNode = this.#trees.get(root) ?? this.#stubify(curPath, void 0);
+    try {
+      for (const part of parts) {
+        assertNoTombstone(curNode);
+        assertNotType(curNode, "file");
+        if (curNode.type === "symlink") {
+          const linkedNode = this.#getNodeResolvingSymlinks(path3.resolve(path3.dirname(curPath), curNode.symlink));
+          assertExists(linkedNode);
+          assertNoTombstone(linkedNode);
+          assertType(linkedNode, "dir");
+          curNode = linkedNode;
+        }
+        assertType(curNode, "dir");
+        assertNoTombstone(curNode);
+        curNode = curNode.dir.get(part) ?? this.#stubify(path3.join(curNode.fullPath, part), curNode);
+        curPath = path3.join(curPath, part);
+      }
+    } catch (e) {
+    }
+    return { pathWithSymlinks: curPath, node: curNode };
+  }
+  #getNode(filePath) {
+    const canonicalPath = path3.resolve(filePath);
+    const { pathWithSymlinks, node } = this.#getNearestAncestorNode(canonicalPath);
+    if (pathWithSymlinks === canonicalPath) {
+      return node;
+    }
+    return void 0;
+  }
+  #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");
+    return this.#getNodeResolvingSymlinks(node.symlink, follows--);
+  }
+  mkdir(filePath, opts = { recursive: false }) {
+    const canonicalPath = path3.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) {
+      assertType(node, "dir");
+      assertNoTombstone(node);
+      node.dir.set(path3.basename(filePath), {
+        type: "dir",
+        fullPath: filePath,
+        parent: node,
+        dir: /* @__PURE__ */ new Map(),
+        needsFlush: true
+      });
+      return;
+    }
+    if (!opts.recursive && path3.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);
+    }
+    for (const dirToMake of toMake) {
+      this.mkdir(dirToMake);
+    }
+  }
+  rmdir(directoryPath) {
+    const node = this.#getNode(directoryPath);
+    if (!node || node.tombstone) {
+      return;
+    }
+    assertType(node, "dir");
+    if (node.stub) {
+      this.#unstubDirectory(node);
+    }
+    if (node.dir.size === 0) {
+      this.#replaceNode(node, {
+        type: "dir",
+        tombstone: true,
+        needsFlush: true
+      });
+    } else {
+      throw new Error("directory not empty");
+    }
+  }
+  exists(filePath) {
+    const node = this.#getNode(filePath);
+    return !!node && !node.tombstone;
+  }
+  readFile(filePath, opts) {
+    let node = this.#getNodeResolvingSymlinks(filePath);
+    if (!node) {
+      return void 0;
+    }
+    assertNotType(node, "dir");
+    assertNoTombstone(node);
+    if (node.stub) {
+      node = this.#replaceNode(node, {
+        type: "file",
+        file: this.fs.readFileSync(filePath),
+        needsFlush: false
+      });
+    }
+    if (!opts) {
+      return Buffer.from(node.file);
+    } else if (opts.asJson) {
+      return JSON.parse(node.file.toString("utf-8"));
+    } else {
+      return node.file.toString(opts.encoding);
+    }
+  }
+  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 existingNode = this.#getNodeResolvingSymlinks(canonicalPath);
+    if (existingNode) {
+      if (existingNode.type === "dir") {
+        throw new Error("cant write file to a dir");
+      }
+      this.#replaceNode(existingNode, {
+        file: fileContentsAsBuffer,
+        type: "file",
+        needsFlush: true
+      });
+      return;
+    }
+    const maybeDirNode = this.#getNodeResolvingSymlinks(path3.dirname(canonicalPath));
+    assertExists(maybeDirNode);
+    assertType(maybeDirNode, "dir");
+    assertNoTombstone(maybeDirNode);
+    maybeDirNode.dir.set(path3.basename(canonicalPath), {
+      type: "file",
+      fullPath: canonicalPath,
+      parent: maybeDirNode,
+      file: fileContentsAsBuffer,
+      needsFlush: true
+    });
+  }
+  deleteFile(filePath) {
+    const canonicalPath = path3.resolve(filePath);
+    const node = this.#getNode(canonicalPath);
+    if (!node || node.type === "file" && node.tombstone === true)
+      return;
+    assertNotType(node, "dir");
+    this.#replaceNode(node, {
+      type: "file",
+      tombstone: true,
+      needsFlush: true
+    });
+  }
+  readJson(filePath) {
+    return this.readFile(filePath, { asJson: true });
+  }
+  writeJson(filePath, o) {
+    return this.writeFile(filePath, JSON.stringify(o, void 0, 2) + "\n", {
+      encoding: "utf-8"
+    });
+  }
+  async #flushFileNode(node) {
+    if (node.tombstone) {
+      try {
+        await this.fs.promises.access(node.fullPath);
+        return this.fs.promises.unlink(node.fullPath);
+      } catch (e) {
+        return;
+      }
+    } 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);
+    }
+    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;
+    }
+  }
+  #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]);
+    }
+  }
+  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];
+    }
+  }
+  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];
+    }
+    if (config.alignment === "left") {
+      return result.padEnd(this.#columnWidths[colNum]);
+    } else {
+      return result.padStart(this.#columnWidths[colNum]);
+    }
+  }
+  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 maxWidth;
+  }
+};
+
+// src/matchesAnyGlob.ts
+var cache = /* @__PURE__ */ new Map();
+var singleMatcherCache = /* @__PURE__ */ new Map();
+var compiledGlobCache = /* @__PURE__ */ new Map();
+var haystackMiss = 0;
+var haystackHit = 0;
+var matchTime = BigInt(0);
+var singleMatcherHits = 0;
+var singleMatcherMisses = 0;
+var singleMatcherSaves = 0;
+var matchesAnyGlob = function matchesAnyGlobFunc(needle, haystack) {
+  matchTime -= process.hrtime.bigint();
+  let cacheForHaystack = cache.get(haystack);
+  if (cacheForHaystack === void 0) {
+    cacheForHaystack = /* @__PURE__ */ new Map();
+    cache.set(haystack, cacheForHaystack);
+  }
+  let result = cacheForHaystack.get(needle);
+  if (result === void 0) {
+    haystackMiss++;
+    result = false;
+    for (const pattern of haystack) {
+      let patternCache = singleMatcherCache.get(pattern);
+      if (patternCache === void 0) {
+        patternCache = /* @__PURE__ */ new Map();
+        singleMatcherCache.set(pattern, patternCache);
+      }
+      result = patternCache.get(needle);
+      if (result === void 0) {
+        let regexp = compiledGlobCache.get(pattern);
+        if (regexp === void 0) {
+          regexp = micromatch.makeRe(pattern);
+          compiledGlobCache.set(pattern, regexp);
+        }
+        singleMatcherMisses++;
+        result = regexp.test(needle);
+        patternCache.set(needle, result);
+      } else {
+        singleMatcherHits++;
+        singleMatcherSaves++;
+      }
+      if (result)
+        break;
+    }
+    cacheForHaystack.set(needle, result);
+  } else {
+    singleMatcherSaves += haystack.length;
+    haystackHit++;
+  }
+  matchTime += process.hrtime.bigint();
+  return result;
+};
+matchesAnyGlob.printStats = () => {
+  const table = new Table({
+    title: "matchesAnyGlob stats",
+    showHeader: true,
+    showFooter: false,
+    columns: [
+      { header: "Stat", type: "string" },
+      { header: "Value", type: "string" }
+    ]
+  });
+  table.addRow("Haystack Miss", "" + haystackMiss);
+  table.addRow("Haystack Hit", "" + haystackHit);
+  table.addRow("Single Glob Hits", "" + singleMatcherHits);
+  table.addRow("Single Glob Misses", "" + singleMatcherMisses);
+  table.addRow("Single Glob Saves", "" + singleMatcherSaves);
+  table.addRow("Total Time", nanosecondsToSanity(matchTime, 6));
+  table.print();
+};
+
+// src/AggregateTiming.ts
+var AggregateTiming = class {
+  constructor(title) {
+    this.title = title;
+  }
+  #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;
+  }
+  stop() {
+    const time = process.hrtime.bigint();
+    if (this.#last) {
+      this.#last.total += time;
+      this.#last = void 0;
+    }
+  }
+  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/Timing.ts
+var Timing = class {
+  constructor(title) {
+    this.title = title;
+    this.stop();
+  }
+  #starts = [];
+  start(name) {
+    this.#starts.push({ name, start: process.hrtime.bigint() });
+  }
+  stop() {
+    this.#starts.push({ start: process.hrtime.bigint() });
+  }
+  printResults() {
+    const table = new Table({
+      sortColumn: -1,
+      showFooter: true,
+      showHeader: true,
+      title: this.title,
+      columns: [
+        {
+          header: "Duration",
+          type: "bigint",
+          renderAs: "nanoseconds",
+          precision: 4,
+          footer: { aggregate: "sum" }
+        },
+        { header: "Task", type: "string", footer: "TOTAL" }
+      ]
+    });
+    this.stop();
+    let cur = this.#starts[0];
+    for (const entry of this.#starts) {
+      if (cur.name) {
+        const span = entry.start - cur.start;
+        table.addRow(span, cur.name);
+      }
+      cur = entry;
+    }
+    table.print();
+  }
+};
+export {
+  AggregateTiming,
+  CachingHost,
+  SimpleHost,
+  Table,
+  Timing,
+  findWorkspaceDir,
+  getPackageNameToDir,
+  getWorkspacePackageDirs,
+  matchesAnyGlob,
+  mutateJson,
+  nanosecondsToSanity
+};
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+/*!
+ * Copyright 2022 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+//# sourceMappingURL=index.js.map