@altano/vitest-plugins 1.1.2 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@altano/vitest-plugins",
-  "version": "1.1.2",
+  "version": "2.0.0",
   "description": "Custom matchers and snapshot serializers to enhance vitest",
   "homepage": "https://github.com/altano/npm-packages/tree/main/packages/vitest-plugins",
   "repository": {
@@ -11,10 +11,14 @@
   "license": "ISC",
   "author": {
     "name": "Alan Norbauer",
-    "email": "altano@gmail.com",
+    "email": "alan@norbauer.com",
     "url": "https://alan.norbauer.com"
   },
   "type": "module",
+  "sideEffects": true,
+  "files": [
+    "src/**/*.ts"
+  ],
   "exports": {
     "./matchers": {
       "types": "./src/matchers/types.d.ts",
@@ -26,26 +30,26 @@
     "./serializers/*": "./src/serializers/*.ts"
   },
   "dependencies": {
-    "@prettier/sync": "^0.5.5",
+    "@prettier/sync": "^0.6.1",
     "exifr": "^7.1.3",
-    "serialize-error": "^11.0.3",
-    "vfile": "^6.0.3",
-    "vitest": "^4.1.0"
+    "serialize-error": "^13.0.2",
+    "vfile": "^6.0.3"
   },
   "devDependencies": {
-    "@types/node": "^25.5.0",
-    "@vitest/coverage-v8": "^4.1.0",
-    "@vitest/expect": "^4.1.0",
+    "@types/node": "^26.6.4",
+    "@vitest/coverage-v8": "^5.0.3",
+    "@vitest/expect": "^5.0.3",
     "depcheck": "^1.4.7",
-    "eslint": "^9.39.4",
-    "prettier": "^3.8.1",
-    "typescript": "^5.9.3",
-    "vite": "^7.3.1",
-    "vitest": "^4.1.0",
+    "eslint": "^10.12.0",
+    "prettier": "3.9.9",
+    "typescript": "^6.0.3",
+    "vite": "^8.3.2",
+    "vitest": "^5.0.3",
     "@altano/tsconfig": "0.0.1"
   },
   "peerDependencies": {
-    "prettier": "3.x.x"
+    "prettier": "3.x.x",
+    "vitest": "5.x.x"
   },
   "publishConfig": {
     "access": "public"
@@ -55,8 +59,8 @@
     "check:types:test": "tsc --noEmit --project ./tests/tsconfig.json",
     "check:unused-dependencies": "depcheck",
     "clean": "rm -rf .turbo && rm -rf .tsbuildinfo && rm -rf node_modules && rm -rf dist",
-    "format": "prettier --check src",
-    "format:fix": "prettier --write src",
+    "format": "prettier --check .",
+    "format:fix": "prettier --write .",
     "lint": "eslint",
     "lint:fix": "TIMING=1 pnpm lint --fix",
     "lint:timing": "TIMING=1 pnpm lint",

package/src/matchers/types.d.ts

@@ -1,6 +1,6 @@
 // Have to import these to get declaration merging.
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import type { Assertion, AsymmetricMatchersContaining } from "vitest";
+import type { Matchers } from "vitest";
 
 interface CustomMatchers<R = unknown> {
   /**
@@ -52,9 +52,10 @@ interface ResponseMatchers<R = unknown> {
   toHaveStatus(expectedStatus: number): R;
 }
 
-/* eslint-disable @typescript-eslint/no-empty-object-type */
 declare module "vitest" {
-  interface Assertion<T> extends CustomMatchers<T> {}
-  interface Assertion<T> extends ResponseMatchers<T> {}
-  interface AsymmetricMatchersContaining extends CustomMatchers {}
+  // Type parameters must match the original declaration exactly, so the
+  // unused `T` has to stay.
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  interface Matchers<R extends void | Promise<void>, T>
+    extends CustomMatchers<R>, ResponseMatchers<R> {}
 }

package/CHANGELOG.md

@@ -1,54 +0,0 @@
-# @altano/vitest-plugins
-
-## 1.1.2
-
-### Patch Changes
-
-- 72b15cc: update dependencies
-- fb3c931: upgrade tsdown
-
-## 1.1.1
-
-### Patch Changes
-
-- b461e76: fix readme
-
-## 1.1.0
-
-### Minor Changes
-
-- e07daa2: add explicit types export for matchers
-
-## 1.0.0
-
-### Major Changes
-
-- 989abbb: added snapshot serializers and a matcher
-
-### Patch Changes
-
-- 4c2162f: remove unused dependencies
-
-## 0.2.0
-
-### Minor Changes
-
-- e936f78: removed sideEffects:true from package.json
-
-## 0.1.1
-
-### Patch Changes
-
-- 2266961: fix import extensions for node libraries
-
-## 0.1.0
-
-### Minor Changes
-
-- f2dda42: new filesystem matchers
-
-## 0.0.2
-
-### Patch Changes
-
-- 7d75608: initial package publish

package/src/serializers/.prettierrc.json

@@ -1,5 +0,0 @@
-{
-  "printWidth": 80,
-  "semi": true,
-  "trailingComma": "all"
-}

package/tests/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "include": ["."],
-  "compilerOptions": {
-    "noEmit": true,
-    "rootDir": "..",
-    "types": ["node", "../src/matchers/types"]
-  }
-}

package/tests/unit/matchers/readme.spec.ts

@@ -1,21 +0,0 @@
-import { describe, expect, it } from "vitest";
-import "../../../src/matchers/setup";
-
-describe("readme", () => {
-  it("should describe toMatchError", () => {
-    expect(new Error("face")).toMatchError(
-      expect.objectContaining({
-        stack: expect.stringContaining("readme.spec.ts") as unknown,
-      }),
-    );
-  });
-  it("should describe toThrowErrorMatching", () => {
-    expect(() => {
-      throw new Error("face");
-    }).toThrowErrorMatching(
-      expect.objectContaining({
-        stack: expect.stringContaining("readme.spec.ts") as unknown,
-      }),
-    );
-  });
-});

package/tests/unit/matchers/response/toHaveHeader.spec.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest";
-import "../../../../src/matchers/setup";
-
-describe("toHaveHeader", () => {
-  const r = new Response("", {
-    headers: {
-      "Content-Type": "image/png",
-    },
-  });
-
-  it("should pass when the property exists", async () => {
-    expect(r).toHaveHeader("Content-Type");
-  });
-  it("should pass when the property doesn't exist", async () => {
-    expect(r).not.toHaveHeader("face");
-  });
-  it("should pass when the property value is correct", async () => {
-    expect(r).toHaveHeader("Content-Type", "image/png");
-  });
-  it("should pass when the property value is incorrect", async () => {
-    expect(r).not.toHaveHeader("Content-Type", 15);
-    expect(r).not.toHaveHeader("face", 15);
-  });
-  it("should error when the property should not exist but does", async () => {
-    expect(() =>
-      expect(r).not.toHaveHeader("Content-Type"),
-    ).toThrowErrorMatchingInlineSnapshot(`[Error: Received should not have the header "Content-Type"]`);
-  });
-  it("should error when the property should exist but doesn't", async () => {
-    expect(() =>
-      expect(r).toHaveHeader("face"),
-    ).toThrowErrorMatchingInlineSnapshot(`[Error: Received does not have the header "face"]`);
-  });
-  it("should error when the value should not match but does", async () => {
-    expect(() =>
-      expect(r).not.toHaveHeader("Content-Type", "image/png"),
-    ).toThrowErrorMatchingInlineSnapshot(`[Error: Header "Content-Type" should not be expected value]`);
-  });
-  it("should error when the value should match but doesn't", async () => {
-    expect(() =>
-      expect(r).toHaveHeader("Content-Type", 17),
-    ).toThrowErrorMatchingInlineSnapshot(`[Error: Header "Content-Type" is not expected value]`);
-  });
-  it("should error when a non-buffer is passed in", async () => {
-    expect(() =>
-      expect(1234).toHaveHeader("face"),
-    ).toThrowErrorMatchingInlineSnapshot(`[TypeError: Cannot read properties of undefined (reading 'has')]`);
-  });
-});

package/tests/unit/matchers/response/toHaveStatus.spec.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-import "../../../../src/matchers/setup";
-
-const getResponse = (status: number): Response =>
-  new Response("", {
-    status,
-  });
-
-describe("toHaveStatus", () => {
-  const status200 = getResponse(200);
-  const status404 = getResponse(404);
-
-  it("should pass when the status is correct", async () => {
-    expect(status200).toHaveStatus(200);
-    expect(status404).toHaveStatus(404);
-  });
-  it("should pass when the status is incorrect", async () => {
-    expect(status200).not.toHaveStatus(500);
-    expect(status404).not.toHaveStatus(500);
-  });
-  it("should error when the value should not match but does", async () => {
-    expect(() =>
-      expect(status200).not.toHaveStatus(200),
-    ).toThrowErrorMatchingInlineSnapshot(
-      `[Error: Status should not be expected value]`,
-    );
-  });
-  it("should error when the value should match but doesn't", async () => {
-    expect(() =>
-      expect(status200).toHaveStatus(500),
-    ).toThrowErrorMatchingInlineSnapshot(
-      `[Error: Status is not expected value]`,
-    );
-  });
-  it("should error when a non-Response is passed in", async () => {
-    expect(() =>
-      expect(1234).toHaveStatus(3),
-    ).toThrowErrorMatchingInlineSnapshot(
-      `[Error: Status is not expected value]`,
-    );
-  });
-});

package/tests/unit/matchers/toBeDirectory.spec.ts

@@ -1,33 +0,0 @@
-import os from "node:os";
-import { describe, expect, it } from "vitest";
-import "../../../src/matchers/setup";
-
-describe("matchers", () => {
-  describe("toBeDirectory", () => {
-    it("should recognize the root", () => {
-      expect("/").toBeDirectory();
-    });
-    it("should recognize the home directory", () => {
-      expect(os.homedir()).toBeDirectory();
-    });
-    it("should recognize this test's directory", () => {
-      expect(import.meta.dirname).toBeDirectory();
-    });
-    it("should not match on garbage", () => {
-      expect("fucking garbage").not.toBeDirectory();
-    });
-    it("should not match on a made up dir", () => {
-      expect("/some/plausible/horseshit").not.toBeDirectory();
-    });
-    it("should NOT recognize this test file as a directory", () => {
-      expect(import.meta.filename).not.toBeDirectory();
-    });
-    it("should throw an error when not a directory", () => {
-      expect(() => {
-        expect("face").toBeDirectory();
-      }).toThrowErrorMatchingInlineSnapshot(
-        `[Error: Received is not a directory (or cannot be accessed by the current user)]`,
-      );
-    });
-  });
-});

package/tests/unit/matchers/toBeFile.spec.ts

@@ -1,20 +0,0 @@
-import { describe, expect, it } from "vitest";
-import "../../../src/matchers/setup";
-
-describe("matchers", () => {
-  describe("toBeFile", () => {
-    it("should recognize this test file as a file", () => {
-      expect(import.meta.filename).toBeFile();
-    });
-    it("should NOT recognize this test directory as a file", () => {
-      expect(import.meta.dirname).not.toBeFile();
-    });
-    it("should throw an error when not a file", () => {
-      expect(() => {
-        expect("face").toBeFile();
-      }).toThrowErrorMatchingInlineSnapshot(
-        `[Error: face is not a file (or cannot be accessed by the current user)]`,
-      );
-    });
-  });
-});

package/tests/unit/matchers/toBePath.spec.ts

@@ -1,32 +0,0 @@
-import path from "node:path";
-import { describe, expect, it } from "vitest";
-import "../../../src/matchers/setup";
-
-describe("matchers", () => {
-  describe("toBePath", () => {
-    it("should recognize this test file as a file", () => {
-      const weirdPath = path.join(
-        import.meta.dirname,
-        "..",
-        path.basename(import.meta.dirname),
-      );
-      expect(import.meta.dirname).toBePath(weirdPath);
-    });
-    it("should throw an error for a non-matching path", () => {
-      const wrongPath = path.join(import.meta.dirname, "..");
-      expect(() => {
-        expect(import.meta.dirname).toBePath(wrongPath);
-      }).toThrowErrorMatchingInlineSnapshot(
-        `[Error: The realpath of the received path did not match the expected one]`,
-      );
-    });
-    it("should throw an error for a path that isn't accessible", () => {
-      const nonExistentPath = path.join(import.meta.dirname, "face");
-      expect(() => {
-        expect(import.meta.dirname).toBePath(nonExistentPath);
-      }).toThrowErrorMatchingInlineSnapshot(
-        `[Error: One of the paths wasn't an accessible file on disk and couldn't be compared]`,
-      );
-    });
-  });
-});

package/tests/unit/matchers/toEqualFile.spec.ts

@@ -1,28 +0,0 @@
-import { describe, expect, it } from "vitest";
-import "../../../src/matchers/setup";
-import path from "node:path";
-
-describe("matchers", () => {
-  describe("toEqualFile", () => {
-    // Okay this is a silly test but *shrug*
-    it("should produce a hash of this test file", () => {
-      expect(import.meta.filename).toEqualFile(import.meta.filename);
-    });
-    it("should fail when given two differing files", async () => {
-      expect(() => {
-        expect(import.meta.filename).toEqualFile(
-          path.join(import.meta.dirname, "toBePath.spec.ts"),
-        );
-      }).toThrowErrorMatchingInlineSnapshot(
-        `[Error: The checksum of the file contents of the files do not match]`,
-      );
-    });
-    it("should fail when given a non-existent file", async () => {
-      expect(() => {
-        expect("faaaaaaaaaace").toEqualFile("khaaaaaaaaan");
-      }).toThrowErrorMatchingInlineSnapshot(
-        `[Error: ENOENT: no such file or directory, open 'faaaaaaaaaace']`,
-      );
-    });
-  });
-});

package/tests/unit/matchers/toHaveExifProperty.spec.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from "vitest";
-import "../../../src/matchers/setup";
-
-describe("toHaveExifProperty", () => {
-  const buffer = Buffer.from(
-    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2O4v3EyBwAGwgIsY3pRcwAAAABJRU5ErkJggg==",
-    "base64url",
-  );
-
-  it("should pass when the property exists", async () => {
-    await expect(buffer).toHaveExifProperty("ImageWidth");
-  });
-  it("should pass when the property doesn't exist", async () => {
-    await expect(buffer).not.toHaveExifProperty("face");
-  });
-  it("should pass when the property value is correct", async () => {
-    await expect(buffer).toHaveExifProperty("ImageHeight", 1);
-    await expect(buffer).toHaveExifProperty("ImageWidth", 1);
-  });
-  it("should pass when the property value is incorrect", async () => {
-    await expect(buffer).not.toHaveExifProperty("ImageWidth", 15);
-    await expect(buffer).not.toHaveExifProperty("face", 15);
-  });
-  it("should error when the property should not exist but does", async () => {
-    await expect(async () =>
-      expect(buffer).not.toHaveExifProperty("ImageWidth"),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[Error: Received should not have the property "ImageWidth"]`,
-    );
-  });
-  it("should error when the property should exist but doesn't", async () => {
-    await expect(async () =>
-      expect(buffer).toHaveExifProperty("face"),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[Error: Received does not have the property "face"]`,
-    );
-  });
-  it("should error when the value should not match but does", async () => {
-    await expect(async () =>
-      expect(buffer).not.toHaveExifProperty("ImageWidth", 1),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[Error: Property "ImageWidth" should not be expected value]`,
-    );
-  });
-  it("should error when the value should match but doesn't", async () => {
-    await expect(async () =>
-      expect(buffer).toHaveExifProperty("ImageWidth", 17),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[Error: Property "ImageWidth" is not expected value]`,
-    );
-  });
-  it("should error when a non-buffer is passed in", async () => {
-    await expect(async () =>
-      expect(1234).toHaveExifProperty("face"),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[Error: Invalid input argument]`,
-    );
-  });
-});

package/tests/unit/matchers/toMatchError.spec.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from "vitest";
-import "../../../src/matchers/setup";
-
-describe("matchers", () => {
-  describe("toMatchError", () => {
-    it("should match an error exactly", () => {
-      expect(new Error("face")).toMatchError(
-        expect.objectContaining({
-          message: "face",
-          name: "Error",
-          stack: expect.any(String) as unknown,
-        }),
-      );
-    });
-    it("should match an error by substring", () => {
-      expect(new Error("your stupid face")).toMatchError(
-        expect.objectContaining({
-          message: expect.stringContaining("stupid") as unknown,
-        }),
-      );
-    });
-    it("should NOT match an invalid string", () => {
-      expect(new Error("face")).not.toMatchError(
-        expect.objectContaining({
-          message: "hat",
-        }),
-      );
-    });
-    it("should throw an error when there is no match", () => {
-      expect(() => {
-        expect(new Error("face")).toMatchError(
-          expect.objectContaining({
-            message: "hat",
-          }),
-        );
-      }).toThrowErrorMatchingInlineSnapshot(
-        `[Error: Expected errors to match]`,
-      );
-    });
-    it.todo("should display the other Error fields in the error", () => {
-      // I don't know how to capture vitest's full error output to verify it
-      // contains what we expect.
-    });
-  });
-});

package/tests/unit/matchers/toThrowErrorMatching.spec.ts

@@ -1,31 +0,0 @@
-import { describe, expect, it } from "vitest";
-import "../../../src/matchers/setup";
-
-describe("matchers", () => {
-  describe("toThrowErrorMatching", () => {
-    it("should match an error exactly", () => {
-      expect(() => {
-        throw new Error("face");
-      }).toThrow("fac");
-    });
-    it("should NOT match an just the message", () => {
-      expect(() => {
-        throw new Error("face");
-      }).not.toThrowErrorMatching("face");
-    });
-    it("should NOT match an invalid message", () => {
-      expect(() => {
-        throw new Error("face");
-      }).not.toThrowErrorMatching(
-        expect.objectContaining({
-          message: "hat",
-        }),
-      );
-    });
-    it("should throw an error when an error wasn't thrown", () => {
-      expect(() => {
-        expect(() => 1).toThrowErrorMatching("face");
-      }).toThrowErrorMatchingInlineSnapshot(`[Error: Did not throw an Error]`);
-    });
-  });
-});

package/tests/unit/serializers/absolutePath.spec.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import absolutePathSerializer from "../../../src/serializers/absolutePath.js";
-expect.addSnapshotSerializer(absolutePathSerializer);
-
-describe("serializers", () => {
-  describe("absolutePath", () => {
-    it("should remove absolute file paths in a string", () => {
-      expect(
-        `String with an absolute path: ${import.meta.dirname}`,
-      ).toMatchInlineSnapshot(
-        `"String with an absolute path: <cwd>/tests/unit/serializers"`,
-      );
-    });
-  });
-});

package/tests/unit/serializers/html.spec.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import htmlSerializer from "../../../src/serializers/html.js";
-expect.addSnapshotSerializer(htmlSerializer);
-
-describe("serializers", () => {
-  describe("html", () => {
-    it("should prettier format the html", () => {
-      expect(
-        `<html><head><title>your face</title></head><body>is stupid</body></html>`,
-      ).toMatchInlineSnapshot(`
-        "<!-- Formatted HTML -->
-        <html>
-          <head>
-            <title>your face</title>
-          </head>
-          <body>
-            is stupid
-          </body>
-        </html>"
-      `);
-    });
-    it("should ignore already formatted html", () => {
-      const html = `
-        <html>
-          <head>
-            <title>your face</title>
-          </head>
-          <body>
-            is stupid
-          </body>
-        </html>"
-      `;
-      expect(html).toMatchInlineSnapshot(`
-        "
-                <html>
-                  <head>
-                    <title>your face</title>
-                  </head>
-                  <body>
-                    is stupid
-                  </body>
-                </html>"
-              "
-      `);
-    });
-    it("should ignore non-html strings", () => {
-      expect(`I'm just some content that isn't html`).toMatchInlineSnapshot(
-        `"I'm just some content that isn't html"`,
-      );
-    });
-    it("should ignore malformed html", () => {
-      expect(`<html><p>oiajsdfpoiajsdf</a></q></face>`).toMatchInlineSnapshot(`
-        "<html><p>oiajsdfpoiajsdf</a></q></face>"
-      `);
-    });
-  });
-});

package/tests/unit/serializers/url.spec.ts

@@ -1,14 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import urlSerializer from "../../../src/serializers/url.js";
-expect.addSnapshotSerializer(urlSerializer);
-
-describe("serializers", () => {
-  describe("url", () => {
-    it("should remove the port in a localhost http[s] url", () => {
-      expect(
-        `String with http://localhost:1234/path/to/face url`,
-      ).toMatchInlineSnapshot(`"String with http://localhost/path/to/face url"`);
-    });
-  });
-});

package/tests/unit/serializers/vFile.spec.ts

@@ -1,80 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { VFile } from "vfile";
-
-// We're not testing the absolute path serializer, but the test isn't
-// reproducible without it. So just add both.
-import "../../../src/serializers/setup";
-
-describe("serializers", () => {
-  describe("vFile", () => {
-    it("should produce a snapshot for a plain text VFile (not Prettier supported)", () => {
-      const file = new VFile({
-        path: "~/example.txt",
-        value: "Alpha *braavo* charlie.",
-      });
-      expect(file).toMatchInlineSnapshot(`
-        FormattedVFile {
-          "cwd": "<cwd>",
-          "data": {},
-          "history": [
-            "~/example.txt",
-          ],
-          "messages": [],
-          "value": "Alpha *braavo* charlie.",
-        }
-      `);
-    });
-    it("should produce a formatted snapshot for a Prettier-compatible file", () => {
-      const file = new VFile({
-        path: "~/example.js",
-        value: `function face(  ) {console.log("hi" );   }`,
-      });
-      expect(file).toMatchInlineSnapshot(`
-        FormattedVFile {
-          "cwd": "<cwd>",
-          "data": {},
-          "history": [
-            "~/example.js",
-          ],
-          "messages": [],
-          "value": "function face() {
-          console.log("hi");
-        }",
-        }
-      `);
-    });
-    it("should throw if given a file that Prettier supports but can't format", () => {
-      const file = new VFile({
-        path: "~/example.js",
-        value: `function (  ) {1   }`,
-      });
-      file.cwd = "/root/path"; // make snapshot reproducible
-      expect(() => {
-        expect(file).toMatchInlineSnapshot(`"function (  ) {1   }"`);
-      }).toThrowErrorMatchingInlineSnapshot(`
-        [PrettyFormatPluginError: Unexpected token (1:10)
-        > 1 | function (  ) {1   }
-            |          ^]
-      `);
-    });
-    it("should remove absolute file paths in a vFile", () => {
-      const file = new VFile({
-        path: "~/example.json",
-        value: `{ "key": "${import.meta.dirname}" }`,
-      });
-      expect(file).toMatchInlineSnapshot(`
-        FormattedVFile {
-          "cwd": "<cwd>",
-          "data": {},
-          "history": [
-            "~/example.json",
-          ],
-          "messages": [],
-          "value": "{
-          "key": "<cwd>/tests/unit/serializers"
-        }",
-        }
-      `);
-    });
-  });
-});

package/tsconfig.json

@@ -1,4 +0,0 @@
-{
-  "extends": "@altano/tsconfig/node.json",
-  "include": ["src", "*.config.ts"]
-}

package/vitest.config.ts

@@ -1,18 +0,0 @@
-import { defineConfig, type ViteUserConfig } from "vitest/config";
-
-const config: ViteUserConfig = defineConfig({
-  test: {
-    dir: "tests/unit",
-    coverage: {
-      enabled: true,
-      include: ["src"],
-      provider: "v8",
-      clean: true,
-      skipFull: true,
-      thresholds: { "100": true },
-      reportsDirectory: ".coverage",
-    },
-  },
-});
-
-export default config;