@monorepolint/utils 0.5.0-alpha.84 → 0.5.0-alpha.85

package/src/Table.ts

@@ -0,0 +1,319 @@
+/*!
+ * Copyright 2022 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+// tslint:disable:no-console
+import { nanosecondsToSanity } from "./nanosecondsToSanity";
+
+type HeaderFooterHelper<HB, FB, H, F> = (HB extends true ? { header: H } : { header?: H }) &
+  (FB extends true ? { footer: F } : { footer?: F });
+
+type WithAlignemnt = { alignment?: "right" | "left" };
+type BaseCellConfig = WithAlignemnt & { type: "bigint" | "string" };
+
+type BaseBigIntCellConfig = {
+  type: "bigint";
+  renderAs?: "nanoseconds";
+  precision?: number;
+} & WithAlignemnt;
+type BaseStringCellConfig = { type: "string" } & WithAlignemnt;
+
+type BigIntColumnConfig<H, F> = WithAlignemnt &
+  BaseBigIntCellConfig &
+  HeaderFooterHelper<H, F, string, AggregateFooterConfig | StaticFooterConfig>;
+
+type StringColumnConfig<H, F> = WithAlignemnt &
+  BaseStringCellConfig &
+  HeaderFooterHelper<H, F, string, StaticFooterConfig>;
+
+type AggregateFooterConfig = {
+  aggregate: "sum" | "average";
+  renderAs?: "nanoseconds";
+  precision?: number;
+} & WithAlignemnt;
+
+type StaticFooterConfig = StrictStaticFooterConfig | string;
+type StrictStaticFooterConfig = {
+  aggregate: "static";
+  value: string;
+} & WithAlignemnt;
+
+type AnyStrictFooterConfig = AggregateFooterConfig | StrictStaticFooterConfig;
+
+type TableConfig<T extends any[], H extends boolean, F extends boolean> = {
+  sortColumn?: number;
+  padding?: number;
+  showHeader: H;
+  showFooter: F;
+  columns: {
+    [K in keyof T]: T[K] extends bigint ? BigIntColumnConfig<H, F> : StringColumnConfig<H, F>;
+  };
+  title: string;
+};
+
+type InternalTableConfig = {
+  padding: number;
+  showHeader: boolean;
+  showFooter: boolean;
+  sortColumn?: number;
+  columns: Array<BigIntColumnConfig<any, any> | StringColumnConfig<any, any>>;
+  title: string;
+};
+
+export class Table<T extends any[]> {
+  #rows: T[] = [];
+  #config: InternalTableConfig;
+  #columnWidths: number[] = [];
+  #footer: Array<bigint | string> = [];
+  #footerRowConfig?: Array<Required<BaseCellConfig> & AnyStrictFooterConfig>;
+  #totalWidth = 0;
+
+  constructor(
+    config:
+      | TableConfig<T, true, true>
+      | TableConfig<T, true, false>
+      | TableConfig<T, false, true>
+      | TableConfig<T, false, false>
+  ) {
+    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 === undefined) {
+          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: T) {
+    // TODO: maybe clone the data
+    this.#rows.push(data);
+  }
+
+  #sumColumn(c: number) {
+    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() {
+    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(this.#footer?.[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: string) {
+    const paddingString = "".padStart(this.#config.padding, " ");
+
+    let hr2 = "";
+
+    // tslint:disable-next-line: prefer-for-of
+    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; // .padEnd(this.#columnWidths[c], " ") + paddingString;
+      }
+      hr = hr.trimRight();
+      console.log(hr);
+    }
+  }
+
+  print() {
+    // let data = [...this.#rows];
+    if (this.#config.sortColumn !== undefined) {
+      // todo
+    }
+
+    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: bigint | string, config: BaseBigIntCellConfig | BaseStringCellConfig) {
+    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
+      return nanosecondsToSanity(value as bigint, config.precision ?? 9);
+    } else {
+      return "" + value;
+    }
+  }
+
+  #getCellValueAligned(value: bigint | string, config: BaseBigIntCellConfig | BaseStringCellConfig, column: number) {
+    let result: string;
+    if (config.type === "bigint" && config.renderAs === "nanoseconds") {
+      result = nanosecondsToSanity(value as bigint, 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: number, rowNum: number) {
+    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: number, rowNum: number) {
+    const config = this.#config.columns[colNum];
+
+    let result: string;
+    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: number, config: BigIntColumnConfig<boolean, boolean> | StringColumnConfig<boolean, boolean>) {
+    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);
+      //   if (config.type == "bigint" && config.renderAs === "nanoseconds") {
+      // maxWidth = Math.max(maxWidth, Number(row[colNum] / BigInt(1000000000)) + 10); // 1 for period, 9 for digits
+      //   } else if (config.type == "bigint" || config.type == "string") {
+      // maxWidth = Math.max(maxWidth, ("" + row[colNum]).length);
+      //   }
+    }
+
+    return maxWidth;
+  }
+}

package/src/Timing.ts

@@ -0,0 +1,55 @@
+/*!
+ * Copyright 2022 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+// tslint:disable:no-console
+import { Table } from "./Table";
+
+export class Timing {
+  #starts: Array<{ name?: string; start: bigint }> = [];
+  constructor(private title: string) {
+    this.stop(); // make sure we have starting point
+  }
+
+  public start(name: string) {
+    this.#starts.push({ name, start: process.hrtime.bigint() });
+  }
+
+  public stop() {
+    this.#starts.push({ start: process.hrtime.bigint() });
+  }
+
+  public printResults() {
+    const table = new Table<[bigint, string]>({
+      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(); // be sure we stopped the last one
+
+    let cur: { name?: string; start: bigint } = 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();
+  }
+}

package/src/__tests__/CachingHost.spec.ts

@@ -0,0 +1,244 @@
+/*!
+ * Copyright 2022 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+
+import { CachingHost } from "../CachingHost";
+import * as realfs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+interface TestCase<T> {
+  getFs: () => T;
+  createTmpDir: () => string;
+}
+
+class RealFsTestCase implements TestCase<typeof realfs> {
+  getFs = () => {
+    return realfs;
+  };
+  createTmpDir = () => {
+    return realfs.mkdtempSync(path.join(os.tmpdir(), "mrl-test"));
+  };
+}
+
+describe(CachingHost, () => {
+  describe.each([["fs", new RealFsTestCase()]])("%s", (_testCaseName, testCase) => {
+    let baseDir: string;
+    let fs: ReturnType<typeof testCase.getFs>;
+
+    let SYMLINK_JSON_PATH: string;
+    let SYMLINK_TXT_PATH: string;
+    let FILE_JSON_PATH: string;
+    let FILE_TXT_PATH: string;
+
+    beforeEach(() => {
+      fs = testCase.getFs();
+      baseDir = testCase.createTmpDir();
+
+      SYMLINK_JSON_PATH = path.resolve(baseDir, "symlink.json");
+      SYMLINK_TXT_PATH = path.resolve(baseDir, "symlink.txt");
+      FILE_TXT_PATH = path.resolve(baseDir, "file.txt");
+      FILE_JSON_PATH = path.resolve(baseDir, "file.json");
+
+      fs.writeFileSync(FILE_JSON_PATH, JSON.stringify({ hi: "mom" }), { encoding: "utf-8" });
+      fs.symlinkSync(FILE_JSON_PATH, SYMLINK_JSON_PATH);
+
+      fs.writeFileSync(FILE_TXT_PATH, "hi dad", { encoding: "utf-8" });
+      fs.symlinkSync(FILE_TXT_PATH, SYMLINK_TXT_PATH);
+    });
+
+    function expectFileToExist(file: string) {
+      return expect(fs.existsSync(file));
+    }
+
+    function expectFileContents(file: string) {
+      return expect(fs.readFileSync(file, { encoding: "utf-8" }));
+    }
+
+    function expectSymlinkTarget(src: string, target: string) {
+      const stat = fs.lstatSync(src);
+      expect(stat.isSymbolicLink() && fs.readlinkSync(src)).toEqual(target);
+    }
+
+    it("Answers exists() properly", async () => {
+      expect.assertions(2);
+      await realfs.promises.writeFile(path.join(baseDir, "b.txt"), "hi", { encoding: "utf-8" });
+      const host = new CachingHost(fs as any);
+      expect(host.exists(path.join(baseDir, "b.txt"))).toBe(true);
+      expect(host.exists(path.join(baseDir, "nosuchfile.txt"))).toBe(false);
+    });
+
+    it("properly handles deletes", async () => {
+      expect.assertions(2);
+      const host = new CachingHost(fs as any);
+
+      host.writeFile(path.join(baseDir, "b.txt"), "hi", { encoding: "utf-8" });
+      host.deleteFile(path.join(baseDir, "b.txt"));
+      host.deleteFile(path.join(baseDir, "a.json"));
+
+      await host.flush();
+
+      expectFileToExist(path.join(baseDir, "b.txt")).toBeFalsy();
+      expectFileToExist(path.join(baseDir, "a.txt")).toBeFalsy();
+    });
+
+    it("handles simple read/write workflow", async () => {
+      expect.assertions(1);
+
+      const host = new CachingHost(fs as any);
+      host.writeFile(FILE_JSON_PATH, "cow", { encoding: "utf-8" });
+
+      expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual("cow");
+    });
+
+    it("handles target symlink changing", async () => {
+      expect.assertions(1);
+
+      const host = new CachingHost(fs as any);
+      host.writeFile(FILE_JSON_PATH, "cow", { encoding: "utf-8" });
+
+      expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual("cow");
+    });
+
+    it("handles writing symlinks properly", async () => {
+      expect.assertions(8);
+
+      const host = new CachingHost(fs as any);
+
+      // file.json should now hold "hmm"
+      host.writeFile(SYMLINK_JSON_PATH, "hmm", { encoding: "utf-8" });
+
+      expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
+      expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
+
+      // Write it out so we can verify disk is right
+      await host.flush();
+
+      expectFileToExist(SYMLINK_JSON_PATH).toBeTruthy();
+      expectFileToExist(FILE_TXT_PATH).toBeTruthy();
+
+      expectFileContents(FILE_JSON_PATH).toBe("hmm");
+      expectFileContents(SYMLINK_JSON_PATH).toBe("hmm");
+
+      expectSymlinkTarget(SYMLINK_JSON_PATH, FILE_JSON_PATH);
+
+      expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
+    });
+
+    it("handles writing symlinks properly if you read it first", async () => {
+      expect.assertions(8);
+
+      const host = new CachingHost(fs as any);
+      host.readFile(SYMLINK_JSON_PATH);
+
+      // file.json should now hold "hmm"
+      host.writeFile(path.join(baseDir, "symlink.json"), "hmm", { encoding: "utf-8" });
+
+      expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
+      expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
+
+      // Write it out so we can verify disk is right
+      await host.flush();
+
+      expectFileToExist(SYMLINK_JSON_PATH).toBeTruthy();
+      expectFileToExist(FILE_TXT_PATH).toBeTruthy();
+
+      expectFileContents(FILE_JSON_PATH).toBe("hmm");
+      expectFileContents(SYMLINK_JSON_PATH).toBe("hmm");
+
+      expectSymlinkTarget(SYMLINK_JSON_PATH, FILE_JSON_PATH);
+
+      expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
+    });
+
+    it("handles creating new symlinks", async () => {
+      expect.assertions(8);
+
+      const host = new CachingHost(fs as any);
+
+      host.readFile(SYMLINK_JSON_PATH);
+
+      // file.json should now hold "hmm"
+      host.writeFile(path.join(baseDir, "symlink.json"), "hmm", { encoding: "utf-8" });
+
+      expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
+      expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
+
+      // Write it out so we can verify disk is right
+      await host.flush();
+
+      expectFileToExist(SYMLINK_JSON_PATH).toBeTruthy();
+      expectFileToExist(FILE_TXT_PATH).toBeTruthy();
+
+      expectFileContents(FILE_JSON_PATH).toBe("hmm");
+      expectFileContents(SYMLINK_JSON_PATH).toBe("hmm");
+
+      expectSymlinkTarget(SYMLINK_JSON_PATH, FILE_JSON_PATH);
+
+      expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
+    });
+
+    it("makes directories", async () => {
+      expect.assertions(3);
+
+      const host = new CachingHost(fs as any);
+
+      host.mkdir(path.join(baseDir, "foo", "bar", "baz"), { recursive: true });
+
+      // Write it out so we can verify disk is right
+      await host.flush();
+
+      expectFileToExist(path.join(baseDir, "foo")).toBeTruthy();
+      expectFileToExist(path.join(baseDir, "foo", "bar")).toBeTruthy();
+      expectFileToExist(path.join(baseDir, "foo", "bar", "baz")).toBeTruthy();
+    });
+
+    it("can unlink empty dirs", async () => {
+      expect.assertions(1);
+
+      // base setup
+      const fooDirPath = path.join(baseDir, "foo");
+      fs.mkdirSync(fooDirPath, { recursive: true });
+
+      // prep obj
+      const host = new CachingHost(fs as any);
+      host.rmdir(fooDirPath);
+
+      // Write it out so we can verify disk is right
+      await host.flush();
+
+      expectFileToExist(fooDirPath).toBeFalsy();
+    });
+
+    it("doesnt let you delete a directory with files", async () => {
+      expect.assertions(2);
+
+      const fooDirPath = path.join(baseDir, "foo");
+      const barFilePath = path.join(fooDirPath, "bar.txt");
+
+      const host = new CachingHost(fs as any);
+      host.mkdir(fooDirPath, { recursive: true });
+      host.writeJson(barFilePath, { hi: 5 });
+
+      expect(() => {
+        host.rmdir(fooDirPath);
+      }).toThrow();
+
+      // Write it out so we can verify disk is right
+      await host.flush();
+
+      expectFileToExist(fooDirPath).toBeTruthy();
+    });
+
+    it("doesn't let you rmdir() a file", () => {
+      expect.assertions(1);
+      const host = new CachingHost(fs as any);
+      expect(() => {
+        host.rmdir(FILE_JSON_PATH);
+      }).toThrow();
+    });
+  });
+});

package/src/findWorkspaceDir.ts

@@ -5,15 +5,14 @@
  *
  */
 
-import { existsSync } from "fs";
 import * as path from "path";
+import { Host } from "./Host";
 import { PackageJson } from "./PackageJson";
-import { readJson } from "./readJson";
 
-export function findWorkspaceDir(dir: string): string | undefined {
+export function findWorkspaceDir(host: Pick<Host, "readJson" | "exists">, dir: string): string | undefined {
   const packagePath = path.join(dir, "package.json");
-  if (existsSync(packagePath)) {
-    const packageJson = readJson(packagePath) as PackageJson;
+  if (host.exists(packagePath)) {
+    const packageJson = host.readJson(packagePath) as PackageJson;
     if (packageJson.workspaces !== undefined) {
       return dir;
     }
@@ -24,5 +23,5 @@ export function findWorkspaceDir(dir: string): string | undefined {
     return undefined;
   }
 
-  return findWorkspaceDir(nextDir);
+  return findWorkspaceDir(host, nextDir);
 }

package/src/getPackageNameToDir.ts

@@ -7,20 +7,20 @@
 
 import { join as pathJoin } from "path";
 import { getWorkspacePackageDirs } from "./getWorkspacePackageDirs";
+import { Host } from "./Host";
 import { PackageJson } from "./PackageJson";
-import { readJson } from "./readJson";
 
 /**
  * returns a map of package names to their directories in the workspace.
  * if `resolvePaths` is true, the returned directory names are absolute paths
  * resolved against the `workspaceDir`.
  */
-export function getPackageNameToDir(workspaceDir: string, resolvePaths: boolean = false) {
+export function getPackageNameToDir(host: Pick<Host, "readJson">, workspaceDir: string, resolvePaths: boolean = false) {
   const ret = new Map<string, string>();
 
-  for (const packageDir of getWorkspacePackageDirs(workspaceDir, resolvePaths)) {
+  for (const packageDir of getWorkspacePackageDirs(host, workspaceDir, resolvePaths)) {
     const packagePath = pathJoin(packageDir, "package.json");
-    const { name } = readJson(packagePath) as PackageJson;
+    const { name } = host.readJson(packagePath) as PackageJson;
     if (name === undefined) {
       throw new Error(`Package needs a name: ${packagePath}`);
     }

package/src/getWorkspacePackageDirs.ts

@@ -8,13 +8,17 @@
 import { existsSync } from "fs";
 import glob from "glob";
 import { join as pathJoin, resolve as pathResolve } from "path";
+import { Host } from "./Host";
 import { PackageJson } from "./PackageJson";
-import { readJson } from "./readJson";
 
-export function getWorkspacePackageDirs(workspaceDir: string, resolvePaths: boolean = false) {
+export function getWorkspacePackageDirs(
+  host: Pick<Host, "readJson">,
+  workspaceDir: string,
+  resolvePaths: boolean = false
+) {
   const ret: string[] = [];
 
-  const packageJson: PackageJson = readJson(pathJoin(workspaceDir, "package.json"));
+  const packageJson: PackageJson = host.readJson(pathJoin(workspaceDir, "package.json"));
 
   if (packageJson.workspaces === undefined) {
     throw new Error("Invalid workspaceDir: " + workspaceDir);