@monorepolint/utils 0.6.0-alpha.2 → 0.6.0-alpha.4

package/src/__tests__/CachingHost.spec.ts

@@ -4,11 +4,11 @@
  * Licensed under the MIT license. See LICENSE file in the project root for details.
  *
  */
-import { describe, expect, it, beforeEach } from "vitest";
-import { CachingHost } from "../CachingHost.js";
 import * as realfs from "node:fs";
-import * as path from "node:path";
 import * as os from "node:os";
+import * as path from "node:path";
+import { beforeEach, describe, expect, it } from "vitest";
+import { CachingHost } from "../CachingHost.js";
 
 interface TestCase<T> {
   getFs: () => T;
@@ -25,220 +25,257 @@ class RealFsTestCase implements TestCase<typeof realfs> {
 }
 
 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");
+  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"));
 
-      fs.writeFileSync(FILE_JSON_PATH, JSON.stringify({ hi: "mom" }), { encoding: "utf-8" });
-      fs.symlinkSync(FILE_JSON_PATH, SYMLINK_JSON_PATH);
+        await host.flush();
 
-      fs.writeFileSync(FILE_TXT_PATH, "hi dad", { encoding: "utf-8" });
-      fs.symlinkSync(FILE_TXT_PATH, SYMLINK_TXT_PATH);
-    });
+        expectFileToExist(path.join(baseDir, "b.txt")).toBeFalsy();
+        expectFileToExist(path.join(baseDir, "a.txt")).toBeFalsy();
+      });
 
-    function expectFileToExist(file: string) {
-      return expect(fs.existsSync(file));
-    }
+      it("handles simple read/write workflow", async () => {
+        expect.assertions(1);
 
-    function expectFileContents(file: string) {
-      return expect(fs.readFileSync(file, { encoding: "utf-8" }));
-    }
+        const host = new CachingHost(fs as any);
+        host.writeFile(FILE_JSON_PATH, "cow", { encoding: "utf-8" });
 
-    function expectSymlinkTarget(src: string, target: string) {
-      const stat = fs.lstatSync(src);
-      expect(stat.isSymbolicLink() && fs.readlinkSync(src)).toEqual(target);
-    }
+        expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual(
+          "cow",
+        );
+      });
 
-    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("handles target symlink changing", async () => {
+        expect.assertions(1);
 
-    it("properly handles deletes", async () => {
-      expect.assertions(2);
-      const host = new CachingHost(fs as any);
+        const host = new CachingHost(fs as any);
+        host.writeFile(FILE_JSON_PATH, "cow", { encoding: "utf-8" });
 
-      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"));
+        expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual(
+          "cow",
+        );
+      });
 
-      await host.flush();
+      it("handles writing symlinks properly", async () => {
+        expect.assertions(8);
 
-      expectFileToExist(path.join(baseDir, "b.txt")).toBeFalsy();
-      expectFileToExist(path.join(baseDir, "a.txt")).toBeFalsy();
-    });
+        const host = new CachingHost(fs as any);
 
-    it("handles simple read/write workflow", async () => {
-      expect.assertions(1);
+        // file.json should now hold "hmm"
+        host.writeFile(SYMLINK_JSON_PATH, "hmm", { encoding: "utf-8" });
 
-      const host = new CachingHost(fs as any);
-      host.writeFile(FILE_JSON_PATH, "cow", { 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",
+        );
 
-      expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual("cow");
-    });
+        // Write it out so we can verify disk is right
+        await host.flush();
 
-    it("handles target symlink changing", async () => {
-      expect.assertions(1);
+        expectFileToExist(SYMLINK_JSON_PATH).toBeTruthy();
+        expectFileToExist(FILE_TXT_PATH).toBeTruthy();
 
-      const host = new CachingHost(fs as any);
-      host.writeFile(FILE_JSON_PATH, "cow", { encoding: "utf-8" });
+        expectFileContents(FILE_JSON_PATH).toBe("hmm");
+        expectFileContents(SYMLINK_JSON_PATH).toBe("hmm");
 
-      expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual("cow");
-    });
+        expectSymlinkTarget(SYMLINK_JSON_PATH, FILE_JSON_PATH);
 
-    it("handles writing symlinks properly", async () => {
-      expect.assertions(8);
+        expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual(
+          "hmm",
+        );
+      });
 
-      const host = new CachingHost(fs as any);
+      it("handles writing symlinks properly if you read it first", async () => {
+        expect.assertions(8);
 
-      // file.json should now hold "hmm"
-      host.writeFile(SYMLINK_JSON_PATH, "hmm", { encoding: "utf-8" });
+        const host = new CachingHost(fs as any);
+        host.readFile(SYMLINK_JSON_PATH);
 
-      expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
-      expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
+        // file.json should now hold "hmm"
+        host.writeFile(path.join(baseDir, "symlink.json"), "hmm", {
+          encoding: "utf-8",
+        });
 
-      // Write it out so we can verify disk is right
-      await host.flush();
+        expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual(
+          "hmm",
+        );
+        expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual(
+          "hmm",
+        );
 
-      expectFileToExist(SYMLINK_JSON_PATH).toBeTruthy();
-      expectFileToExist(FILE_TXT_PATH).toBeTruthy();
+        // Write it out so we can verify disk is right
+        await host.flush();
 
-      expectFileContents(FILE_JSON_PATH).toBe("hmm");
-      expectFileContents(SYMLINK_JSON_PATH).toBe("hmm");
+        expectFileToExist(SYMLINK_JSON_PATH).toBeTruthy();
+        expectFileToExist(FILE_TXT_PATH).toBeTruthy();
 
-      expectSymlinkTarget(SYMLINK_JSON_PATH, FILE_JSON_PATH);
+        expectFileContents(FILE_JSON_PATH).toBe("hmm");
+        expectFileContents(SYMLINK_JSON_PATH).toBe("hmm");
 
-      expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
-    });
+        expectSymlinkTarget(SYMLINK_JSON_PATH, FILE_JSON_PATH);
 
-    it("handles writing symlinks properly if you read it first", async () => {
-      expect.assertions(8);
+        expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual(
+          "hmm",
+        );
+      });
 
-      const host = new CachingHost(fs as any);
-      host.readFile(SYMLINK_JSON_PATH);
+      it("handles creating new symlinks", async () => {
+        expect.assertions(8);
 
-      // file.json should now hold "hmm"
-      host.writeFile(path.join(baseDir, "symlink.json"), "hmm", { encoding: "utf-8" });
+        const host = new CachingHost(fs as any);
 
-      expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
-      expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
+        host.readFile(SYMLINK_JSON_PATH);
 
-      // Write it out so we can verify disk is right
-      await host.flush();
+        // file.json should now hold "hmm"
+        host.writeFile(path.join(baseDir, "symlink.json"), "hmm", {
+          encoding: "utf-8",
+        });
 
-      expectFileToExist(SYMLINK_JSON_PATH).toBeTruthy();
-      expectFileToExist(FILE_TXT_PATH).toBeTruthy();
+        expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual(
+          "hmm",
+        );
+        expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual(
+          "hmm",
+        );
 
-      expectFileContents(FILE_JSON_PATH).toBe("hmm");
-      expectFileContents(SYMLINK_JSON_PATH).toBe("hmm");
+        // Write it out so we can verify disk is right
+        await host.flush();
 
-      expectSymlinkTarget(SYMLINK_JSON_PATH, FILE_JSON_PATH);
+        expectFileToExist(SYMLINK_JSON_PATH).toBeTruthy();
+        expectFileToExist(FILE_TXT_PATH).toBeTruthy();
 
-      expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
-    });
+        expectFileContents(FILE_JSON_PATH).toBe("hmm");
+        expectFileContents(SYMLINK_JSON_PATH).toBe("hmm");
 
-    it("handles creating new symlinks", async () => {
-      expect.assertions(8);
+        expectSymlinkTarget(SYMLINK_JSON_PATH, FILE_JSON_PATH);
 
-      const host = new CachingHost(fs as any);
+        expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual(
+          "hmm",
+        );
+      });
 
-      host.readFile(SYMLINK_JSON_PATH);
+      it("makes directories", async () => {
+        expect.assertions(3);
 
-      // file.json should now hold "hmm"
-      host.writeFile(path.join(baseDir, "symlink.json"), "hmm", { encoding: "utf-8" });
+        const host = new CachingHost(fs as any);
 
-      expect(host.readFile(SYMLINK_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
-      expect(host.readFile(FILE_JSON_PATH, { encoding: "utf-8" })).toEqual("hmm");
+        host.mkdir(path.join(baseDir, "foo", "bar", "baz"), {
+          recursive: true,
+        });
 
-      // Write it out so we can verify disk is right
-      await host.flush();
+        // Write it out so we can verify disk is right
+        await host.flush();
 
-      expectFileToExist(SYMLINK_JSON_PATH).toBeTruthy();
-      expectFileToExist(FILE_TXT_PATH).toBeTruthy();
+        expectFileToExist(path.join(baseDir, "foo")).toBeTruthy();
+        expectFileToExist(path.join(baseDir, "foo", "bar")).toBeTruthy();
+        expectFileToExist(path.join(baseDir, "foo", "bar", "baz")).toBeTruthy();
+      });
 
-      expectFileContents(FILE_JSON_PATH).toBe("hmm");
-      expectFileContents(SYMLINK_JSON_PATH).toBe("hmm");
+      it("can unlink empty dirs", async () => {
+        expect.assertions(1);
 
-      expectSymlinkTarget(SYMLINK_JSON_PATH, FILE_JSON_PATH);
+        // base setup
+        const fooDirPath = path.join(baseDir, "foo");
+        fs.mkdirSync(fooDirPath, { recursive: true });
 
-      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();
-    });
+        // prep obj
+        const host = new CachingHost(fs as any);
+        host.rmdir(fooDirPath);
 
-    it("can unlink empty dirs", async () => {
-      expect.assertions(1);
+        // Write it out so we can verify disk is right
+        await host.flush();
 
-      // base setup
-      const fooDirPath = path.join(baseDir, "foo");
-      fs.mkdirSync(fooDirPath, { recursive: true });
+        expectFileToExist(fooDirPath).toBeFalsy();
+      });
 
-      // prep obj
-      const host = new CachingHost(fs as any);
-      host.rmdir(fooDirPath);
+      it("doesnt let you delete a directory with files", async () => {
+        expect.assertions(2);
 
-      // Write it out so we can verify disk is right
-      await host.flush();
+        const fooDirPath = path.join(baseDir, "foo");
+        const barFilePath = path.join(fooDirPath, "bar.txt");
 
-      expectFileToExist(fooDirPath).toBeFalsy();
-    });
+        const host = new CachingHost(fs as any);
+        host.mkdir(fooDirPath, { recursive: true });
+        host.writeJson(barFilePath, { hi: 5 });
 
-    it("doesnt let you delete a directory with files", async () => {
-      expect.assertions(2);
+        expect(() => {
+          host.rmdir(fooDirPath);
+        }).toThrow();
 
-      const fooDirPath = path.join(baseDir, "foo");
-      const barFilePath = path.join(fooDirPath, "bar.txt");
+        // Write it out so we can verify disk is right
+        await host.flush();
 
-      const host = new CachingHost(fs as any);
-      host.mkdir(fooDirPath, { recursive: true });
-      host.writeJson(barFilePath, { hi: 5 });
+        expectFileToExist(fooDirPath).toBeTruthy();
+      });
 
-      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();
-    });
-  });
+      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,11 +5,11 @@
  *
  */
 
+import { findUp } from "find-up";
+import * as fs from "fs";
 import * as path from "path";
 import { Host } from "./Host.js";
 import { PackageJson } from "./PackageJson.js";
-import * as fs from "fs";
-import { findUp } from "find-up";
 
 export async function findPnpmWorkspaceDir(cwd: string) {
   const workspaceManifestLocation = await findUp("pnpm-workspace.yaml", {
@@ -20,7 +20,7 @@ export async function findPnpmWorkspaceDir(cwd: string) {
 
 export async function findWorkspaceDir(
   host: Pick<Host, "readJson" | "exists">,
-  dir: string
+  dir: string,
 ): Promise<string | undefined> {
   // Defining workspaces in package.json is not necessary in PNPM
   const maybePnpmWorkspaceDir = await findPnpmWorkspaceDir(dir);

package/src/getPackageNameToDir.ts

@@ -17,11 +17,15 @@ import { PackageJson } from "./PackageJson.js";
 export async function getPackageNameToDir(
   host: Pick<Host, "readJson" | "exists">,
   workspaceDir: string,
-  resolvePaths: boolean = false
+  resolvePaths: boolean = false,
 ) {
   const ret = new Map<string, string>();
 
-  const workspacePackages = await getWorkspacePackageDirs(host, workspaceDir, resolvePaths);
+  const workspacePackages = await getWorkspacePackageDirs(
+    host,
+    workspaceDir,
+    resolvePaths,
+  );
   for (const packageDir of workspacePackages) {
     const packagePath = pathJoin(packageDir, "package.json");
     const { name } = host.readJson(packagePath) as PackageJson;

package/src/getWorkspacePackageDirs.ts

@@ -5,19 +5,19 @@
  *
  */
 
+import { findPackages } from "find-packages";
 import { existsSync } from "fs";
 import * as glob from "glob";
-import * as path from "node:path";
 import * as fs from "node:fs";
+import * as path from "node:path";
+import readYamlFile from "read-yaml-file";
 import { Host } from "./Host.js";
 import { PackageJson } from "./PackageJson.js";
-import readYamlFile from "read-yaml-file";
-import { findPackages } from "find-packages";
 
 async function findPNPMWorkspacePackages(workspaceRoot: string) {
   workspaceRoot = fs.realpathSync(workspaceRoot);
   const workspaceManifest = await readYamlFile.default<{ packages?: string[] }>(
-    path.join(workspaceRoot, "pnpm-workspace.yaml")
+    path.join(workspaceRoot, "pnpm-workspace.yaml"),
   );
 
   return findPackages(workspaceRoot, {
@@ -30,11 +30,15 @@ async function findPNPMWorkspacePackages(workspaceRoot: string) {
 export async function getWorkspacePackageDirs(
   host: Pick<Host, "readJson" | "exists">,
   workspaceDir: string,
-  resolvePaths: boolean = false
+  resolvePaths: boolean = false,
 ) {
-  const packageJson = host.readJson(path.join(workspaceDir, "package.json")) as PackageJson;
+  const packageJson = host.readJson(
+    path.join(workspaceDir, "package.json"),
+  ) as PackageJson;
 
-  const isPnpmWorkspace = host.exists(path.join(workspaceDir, "pnpm-workspace.yaml"));
+  const isPnpmWorkspace = host.exists(
+    path.join(workspaceDir, "pnpm-workspace.yaml"),
+  );
   if (isPnpmWorkspace) {
     const workspacePackages = await findPNPMWorkspacePackages(workspaceDir);
     if (workspacePackages.length === 0) {
@@ -44,7 +48,9 @@ export async function getWorkspacePackageDirs(
   }
 
   if (!packageJson.workspaces) {
-    throw new Error("Unsupported! Monorepo is not backed by either pnpm nor yarn workspaces.");
+    throw new Error(
+      "Unsupported! Monorepo is not backed by either pnpm nor yarn workspaces.",
+    );
   }
 
   const ret: string[] = [];
@@ -54,7 +60,11 @@ export async function getWorkspacePackageDirs(
 
   for (const pattern of packageGlobs) {
     for (const packagePath of glob.sync(pattern, { cwd: workspaceDir })) {
-      const packageJsonPath = path.join(workspaceDir, packagePath, "package.json");
+      const packageJsonPath = path.join(
+        workspaceDir,
+        packagePath,
+        "package.json",
+      );
 
       if (existsSync(packageJsonPath)) {
         if (resolvePaths === true) {

package/src/index.ts

@@ -5,16 +5,16 @@
  *
  */
 
-export { getWorkspacePackageDirs } from "./getWorkspacePackageDirs.js";
-export { mutateJson } from "./mutateJson.js";
-export { PackageJson } from "./PackageJson.js";
+export { AggregateTiming } from "./AggregateTiming.js";
+export { CachingHost } from "./CachingHost.js";
 export { findWorkspaceDir } from "./findWorkspaceDir.js";
 export { getPackageNameToDir } from "./getPackageNameToDir.js";
+export { getWorkspacePackageDirs } from "./getWorkspacePackageDirs.js";
 export { Host } from "./Host.js";
-export { SimpleHost } from "./SimpleHost.js";
-export { CachingHost } from "./CachingHost.js";
 export { matchesAnyGlob } from "./matchesAnyGlob.js";
+export { mutateJson } from "./mutateJson.js";
 export { nanosecondsToSanity } from "./nanosecondsToSanity.js";
-export { AggregateTiming } from "./AggregateTiming.js";
-export { Timing } from "./Timing.js";
+export { PackageJson } from "./PackageJson.js";
+export { SimpleHost } from "./SimpleHost.js";
 export { Table } from "./Table.js";
+export { Timing } from "./Timing.js";

package/src/matchesAnyGlob.ts

@@ -14,12 +14,18 @@ import { Table } from "./Table.js";
  * Multimap cache of whether a needle was found in the glob haystack. Short circuits many
  * individual checks against the globs.
  */
-const cache = new Map</* haystack */ readonly string[], Map</* needle */ string, /* result */ boolean>>();
+const cache = new Map<
+  /* haystack */ readonly string[],
+  Map</* needle */ string, /* result */ boolean>
+>();
 
 /**
  * Multimap cache of whether a needle matches a glob. Allows us to avoid regexp's.
  */
-const singleMatcherCache = new Map</* glob */ string, Map</* needle */ string, /* result*/ boolean>>();
+const singleMatcherCache = new Map<
+  /* glob */ string,
+  Map</* needle */ string, /* result*/ boolean>
+>();
 
 /**
  * Cache of glob to regular expression. Compiling the regular expression is expensive.
@@ -39,7 +45,10 @@ interface MatchesAnyGlob {
   (needle: string, haystack: readonly string[]): boolean | undefined;
   printStats?: () => void;
 }
-export const matchesAnyGlob: MatchesAnyGlob = function matchesAnyGlobFunc(needle: string, haystack: readonly string[]) {
+export const matchesAnyGlob: MatchesAnyGlob = function matchesAnyGlobFunc(
+  needle: string,
+  haystack: readonly string[],
+) {
   matchTime -= process.hrtime.bigint();
 
   let cacheForHaystack = cache.get(haystack);

package/src/mutateJson.ts

@@ -6,7 +6,11 @@
  */
 
 import { Host } from "./Host.js";
-export function mutateJson<T extends object>(path: string, host: Host, mutator: (f: T) => T) {
+export function mutateJson<T extends object>(
+  path: string,
+  host: Host,
+  mutator: (f: T) => T,
+) {
   let file = host.readJson(path) as T;
   file = mutator(file);
   host.writeJson(path, file);

package/src/nanosecondsToSanity.ts

@@ -6,5 +6,7 @@
  */
 
 export function nanosecondsToSanity(n: bigint, precision: number = 9) {
-  return n / BigInt(1000000000) + "." + ("" + (n % BigInt(1000000000))).padStart(9, "0").substring(0, precision) + "s";
+  return n / BigInt(1000000000) + "."
+    + ("" + (n % BigInt(1000000000))).padStart(9, "0").substring(0, precision)
+    + "s";
 }

package/vitest.config.mjs

@@ -1,14 +1,13 @@
-
-import { coverageConfigDefaults, defineProject, defaultExclude } from 'vitest/config'
+import { coverageConfigDefaults, defaultExclude, defineProject } from "vitest/config";
 
 export default defineProject({
   test: {
-   exclude: [...defaultExclude, "**/build/**"],
+    exclude: [...defaultExclude, "**/build/**"],
     coverage: {
       provider: "v8",
       enabled: true,
-      exclude: [...coverageConfigDefaults.exclude, "vitest.config.*"]
-    }
+      pool: "forks",
+      exclude: [...coverageConfigDefaults.exclude, "vitest.config.*"],
+    },
   },
-})
-          
+});