Refactored tests and fixed #6

package.json

@@ -26,6 +26,7 @@
   "devDependencies": {
     "@changesets/cli": "^2.26.0",
     "@types/node": "^18.14.5",
+    "axios": "^1.4.0",
     "tsup": "^6.6.3",
     "turbo": "^1.8.3",
     "typescript": "^4.9.5",

src/types.ts

@@ -3,8 +3,8 @@ export type NoInfer<T> = [T][T extends any ? 0 : never];
 /**
  * Adapted from type-fest's PartialDeep
  */
-export type PartialDeep<T> = T extends (...args: any[]) => unknown
-  ? T | undefined
+export type PartialDeep<T> = T extends (...args: any[]) => any
+  ? Partial<T> | undefined
   : T extends object
   ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
     ? ItemType[] extends T // Test for arrays (non-tuples) specifically

tests/fromAny.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { Equal, Expect, accept } from "./test-utils";
+import { fromAny } from "../src";
+
+describe("fromAny", () => {
+  it("Should return whatever you pass in", () => {
+    const result = fromAny({ foo: "bar" });
+
+    expect(result).toEqual({ foo: "bar" });
+  });
+
+  it("Should return unknown if not called in a function's args", () => {
+    const result = fromAny({ foo: "bar" });
+
+    type test = Expect<Equal<typeof result, unknown>>;
+  });
+
+  it("Should let you pass anything to a function", () => {
+    accept<{ foo: string; bar: number }>(fromAny("str"));
+
+    accept<{ foo: string; bar: number }>(fromAny(124123));
+
+    accept<{ foo: string; bar: number }>(
+      fromAny({
+        foo: "awdaw",
+      }),
+    );
+  });
+
+  it("When passed into a function, it should NOT give excess property warnings", () => {
+    accept<{
+      foo: string;
+      bar: number;
+    }>(
+      fromAny({
+        foo: "bar",
+        baz: 1,
+      }),
+    );
+  });
+});

tests/fromExact.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { fromAny, fromExact, fromPartial } from "../src";
+import { Equal, Expect, accept } from "./test-utils";
+
+describe("fromExact", () => {
+  it("Should return whatever you pass in", () => {
+    const result = fromExact({ foo: "bar" });
+
+    expect(result).toEqual({ foo: "bar" });
+  });
+
+  it("Should return the type you pass in", () => {
+    const result = fromExact({ foo: "bar" });
+
+    type test = Expect<Equal<typeof result, { foo: string }>>;
+  });
+
+  it("When passed to a function, it should expect the exact type", () => {
+    accept<{ foo: string; bar: number }>(
+      // @ts-expect-error
+      fromExact({
+        foo: "bar",
+      }),
+    );
+  });
+});

tests/utils.test.ts → tests/fromPartial.test.ts

@@ -1,8 +1,7 @@
 import { describe, expect, it } from "vitest";
-import { fromAny, fromExact, fromPartial } from "../src";
-import { Equal, Expect } from "./test-utils";
-
-const accept = <T>(_t: T) => {};
+import { fromPartial } from "../src";
+import { Equal, Expect, accept } from "./test-utils";
+import { AxiosInstance } from "axios";
 
 describe("fromPartial", () => {
   it("Should return whatever you pass in", () => {
@@ -67,65 +66,15 @@ describe("fromPartial", () => {
       }),
     );
   });
-});
-
-describe("fromAny", () => {
-  it("Should return whatever you pass in", () => {
-    const result = fromAny({ foo: "bar" });
-
-    expect(result).toEqual({ foo: "bar" });
-  });
-
-  it("Should return unknown if not called in a function's args", () => {
-    const result = fromAny({ foo: "bar" });
-
-    type test = Expect<Equal<typeof result, unknown>>;
-  });
-
-  it("Should let you pass anything to a function", () => {
-    accept<{ foo: string; bar: number }>(fromAny("str"));
 
-    accept<{ foo: string; bar: number }>(fromAny(124123));
-
-    accept<{ foo: string; bar: number }>(
-      fromAny({
-        foo: "awdaw",
-      }),
-    );
+  it("Should accept functions", () => {
+    accept<() => void>(fromPartial({}));
   });
 
-  it("When passed into a function, it should NOT give excess property warnings", () => {
+  it("Should accept interfaces which combine object properties and a call signature", () => {
     accept<{
+      (): void;
       foo: string;
-      bar: number;
-    }>(
-      fromAny({
-        foo: "bar",
-        baz: 1,
-      }),
-    );
-  });
-});
-
-describe("fromExact", () => {
-  it("Should return whatever you pass in", () => {
-    const result = fromExact({ foo: "bar" });
-
-    expect(result).toEqual({ foo: "bar" });
-  });
-
-  it("Should return the type you pass in", () => {
-    const result = fromExact({ foo: "bar" });
-
-    type test = Expect<Equal<typeof result, { foo: string }>>;
-  });
-
-  it("When passed to a function, it should expect the exact type", () => {
-    accept<{ foo: string; bar: number }>(
-      // @ts-expect-error
-      fromExact({
-        foo: "bar",
-      }),
-    );
+    }>(fromPartial({}));
   });
 });

tests/test-utils.ts

@@ -37,3 +37,5 @@ export type UnionToIntersection<U> = (
   : never;
 
 export const doNotExecute = (func: () => any) => {};
+
+export const accept = <T>(_t: T) => {};