inferred-types 0.19.0 → 0.22.0

package/tests/dictionary/DictPartialApplication.test.ts

@@ -0,0 +1,43 @@
+import { describe, it } from "vitest";
+
+import type { DictPartialApplication } from "src/types";
+import type { Expect, Equal } from "@type-challenges/utils";
+
+describe("DictUnwrapValues<T>", () => {
+  it("happy path", () => {
+    const api = {
+      hi: (name: string) => `hi ${name}`,
+      bye: (name: string) => `bye ${name}`,
+    };
+
+    type Api = typeof api;
+    type T = DictPartialApplication<Api>;
+    type Expected = { hi: string; bye: string };
+
+    type cases = [Expect<Equal<T, Expected>>];
+
+    const cases: cases = [true];
+  });
+
+  it("object which has non-function based props", () => {
+    const api = {
+      theAnswer: 42,
+      hi: (name: string) => `hi ${name}`,
+      bye: (name: string) => `bye ${name}`,
+    };
+
+    type Api = typeof api;
+    type T1 = DictPartialApplication<Api>;
+    type T2 = DictPartialApplication<Api, true>;
+    type T3 = DictPartialApplication<Api, false>;
+    type Expected = { hi: string; bye: string };
+    type Expected3 = { theAnswer: number; hi: string; bye: string };
+
+    type cases = [
+      Expect<Equal<T1, Expected>>,
+      Expect<Equal<T2, Expected>>,
+      Expect<Equal<T3, Expected3>>
+    ];
+    const cases: cases = [true, true, true];
+  });
+});

package/tests/dictionary/DictReturnValues.test.ts

@@ -0,0 +1,32 @@
+import { describe, it } from "vitest";
+
+import type { DictReturnValues } from "src/types";
+import type { Expect, Equal } from "@type-challenges/utils";
+
+describe("DictReturnValues<T, R, O>", () => {
+  it("happy path", () => {
+    const api = {
+      foo: (name: string) => `${name}`,
+      multiply: (v1: number, v2: number) => v1 * v2,
+    };
+
+    type Api = typeof api;
+    // convert all functions
+    type T1 = DictReturnValues<Api, null>;
+    // convert functions with `number` return
+    type T2 = DictReturnValues<Api, null, (...args: any[]) => number>;
+
+    type Expected1 = {
+      foo: (name: string) => null;
+      multiply: (v1: number, v2: number) => null;
+    };
+    type Expected2 = {
+      foo: (name: string) => string;
+      multiply: (v1: number, v2: number) => null;
+    };
+
+    type cases = [Expect<Equal<T1, Expected1>>, Expect<Equal<T2, Expected2>>];
+
+    const cases: cases = [true, true];
+  });
+});

package/tests/dictionary/Get.spec.ts

@@ -1,6 +1,8 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { Get } from "~/types";
-import { defineType } from "~/utility";
+import { Get } from "src/types";
+import { defineType } from "src/utility";
 
 describe("Get<T, K> type utility", () => {
   it("Get<T,K> works with literals and wide types", () => {
@@ -17,7 +19,7 @@ describe("Get<T, K> type utility", () => {
       Expect<Equal<Id, 1234>>,
       Expect<Equal<Foo, number>>,
       Expect<Equal<Bar, string>>,
-      // non-existant props return never
+      // non-existent props return never
       Expect<Equal<Nada, never>>
     ];
     const c: cases = [true, true, true, true];

package/tests/dictionary/PrependValuesWithFunction.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+
+import type { DictPrependWithFn } from "src/types";
+import type { Expect, Equal } from "@type-challenges/utils";
+
+describe("WrapValuesWithFunction<T, R, O>", () => {
+  it("happy path", () => {
+    const api = {
+      static: 42,
+      foo: (name: string) => `${name}`,
+      multiply: (v1: number, v2: number) => v1 * v2,
+    };
+
+    type Api = typeof api;
+    type T1 = DictPrependWithFn<Api, [name: string, age: number]>;
+    type T2 = DictPrependWithFn<Api, [name: string, age: number], Function>;
+
+    type Expected1 = {
+      static: (name: string, age: number) => number;
+      foo: (name: string, age: number) => (name: string) => string;
+      multiply: (name: string, age: number) => (v1: number, v2: number) => number;
+    };
+
+    type Expected2 = {
+      static: number;
+      foo: (name: string, age: number) => (name: string) => string;
+      multiply: (name: string, age: number) => (v1: number, v2: number) => number;
+    };
+
+    type cases = [Expect<Equal<T1, Expected1>>, Expect<Equal<T2, Expected2>>];
+    const cases: cases = [true, true];
+    expect(cases).toBe(cases);
+  });
+});

package/tests/dictionary/RequireProps.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from "vitest";
+import type { Expect, Equal } from "@type-challenges/utils";
+
+import { RequireProps } from "src/types/dictionary";
+
+describe("RequireProps<T,R>", () => {
+  it("works as expected", () => {
+    type Start = { foo?: string; bar?: number };
+    type Foo = RequireProps<Start, "foo">;
+    type Bar = RequireProps<Start, "bar">;
+    type Both = RequireProps<Start, "foo" | "bar">;
+
+    type cases = [
+      Expect<Equal<Foo, { foo: string; bar?: number }>>,
+      Expect<Equal<Bar, { foo?: string; bar: number }>>,
+      Expect<Equal<Both, { foo: string; bar: number }>>
+    ];
+    const cases: cases = [true, true, true];
+    expect(cases).toBe(cases);
+  });
+});

package/tests/dictionaryTransform-spec.ts

@@ -1,7 +1,7 @@
-/* eslint-disable unicorn/consistent-function-scoping */
-import { dictionaryTransform, ExplicitFunction } from "~/utility";
+import { describe, it, expect } from "vitest";
+import { dictionaryTransform, ExplicitFunction } from "../src/utility";
 import { Expect, Equal, NotEqual, ExpectExtends, ExpectFalse } from "@type-challenges/utils";
-import { ToFluent, Transformer } from "~/types";
+import { ToFluent, Transformer } from "../src/types";
 
 describe("dictionaryTransform()", () => {
   type A = { foo: string; bar: string };

package/tests/ifTypeOf-spec.ts

@@ -1,7 +1,8 @@
-/* eslint-disable unicorn/consistent-function-scoping */
+import { describe, it, expect } from "vitest";
+
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Expect, Equal } from "@type-challenges/utils";
-import { ifTypeOf, defineType, literal } from "~/utility";
+import { ifTypeOf, defineType, literal } from "../src/utility";
 
 describe("ifTypeOf() utility", () => {
   it("base validation with extends() returns true/false", () => {
@@ -12,10 +13,7 @@ describe("ifTypeOf() utility", () => {
     expect(yup).toBe(true);
     expect(nope).toBe(false);
 
-    type cases = [
-      Expect<Equal<typeof yup, true>>,
-      Expect<Equal<typeof nope, false>>,
-    ];
+    type cases = [Expect<Equal<typeof yup, true>>, Expect<Equal<typeof nope, false>>];
     const cases: cases = [true, true];
     expect(cases).toBe(cases);
   });
@@ -36,7 +34,7 @@ describe("ifTypeOf() utility", () => {
       Expect<Equal<typeof yup, true>>,
       Expect<Equal<typeof yup2, true>>,
       Expect<Equal<typeof nope1, false>>,
-      Expect<Equal<typeof nope2, false>>,
+      Expect<Equal<typeof nope2, false>>
     ];
     const cases: cases = [true, true, true, true];
     expect(cases).toBe(cases);
@@ -63,7 +61,7 @@ describe("ifTypeOf() utility", () => {
       Expect<Equal<typeof wideNumCompare, true>>,
       Expect<Equal<typeof narrowEquality, true>>,
       Expect<Equal<typeof stringIsNumber, false>>,
-      Expect<Equal<typeof diffNumbersNarrowly, false>>,
+      Expect<Equal<typeof diffNumbersNarrowly, false>>
     ];
     const cases: cases = [true, true, true, true, true];
     expect(cases).toBe(cases);
@@ -76,25 +74,41 @@ describe("ifTypeOf() utility", () => {
 
     expect(fnExtends).toBe(true);
 
-    type cases = [
-      Expect<Equal<typeof fnExtends, true>>
-    ];
+    type cases = [Expect<Equal<typeof fnExtends, true>>];
     const cases: cases = [true];
     expect(cases).toBe(cases);
   });
 
   it("checklist example", () => {
-    const noFoodOrDrink = ifTypeOf({ wakeUp: true }).extends({ wakeUp: true, eatBreakfast: true, drinkCoffee: true });
-    const ready = ifTypeOf({ wakeUp: true, eatBreakfast: true, drinkCoffee: true }).extends({ wakeUp: true, eatBreakfast: true, drinkCoffee: true });
+    const noFoodOrDrink = ifTypeOf({ wakeUp: true }).extends({
+      wakeUp: true,
+      eatBreakfast: true,
+      drinkCoffee: true,
+    });
+    const ready = ifTypeOf({ wakeUp: true, eatBreakfast: true, drinkCoffee: true }).extends({
+      wakeUp: true,
+      eatBreakfast: true,
+      drinkCoffee: true,
+    });
 
     // completely wrong
-    const fullyBaked = ifTypeOf({ wakeUp: false, eatBreakfast: false, drinkCoffee: false }).extends({ wakeUp: true, eatBreakfast: true, drinkCoffee: true });
+    const fullyBaked = ifTypeOf({ wakeUp: false, eatBreakfast: false, drinkCoffee: false }).extends(
+      { wakeUp: true, eatBreakfast: true, drinkCoffee: true }
+    );
 
     // half-right
-    const halfBaked = ifTypeOf({ wakeUp: false, eatBreakfast: false, drinkCoffee: false }).extends({ wakeUp: true, eatBreakfast: true, drinkCoffee: true } as const);
+    const halfBaked = ifTypeOf({ wakeUp: false, eatBreakfast: false, drinkCoffee: false }).extends({
+      wakeUp: true,
+      eatBreakfast: true,
+      drinkCoffee: true,
+    } as const);
 
     // back to right; at the cost of being very careful
-    const lucid = ifTypeOf({ wakeUp: false, eatBreakfast: false, drinkCoffee: false }).narrowlyExtends({ wakeUp: true, eatBreakfast: true, drinkCoffee: true } as const);
+    const lucid = ifTypeOf({
+      wakeUp: false,
+      eatBreakfast: false,
+      drinkCoffee: false,
+    }).narrowlyExtends({ wakeUp: true, eatBreakfast: true, drinkCoffee: true } as const);
 
     // run-time tests of False Positives
     // ---------------------------------
@@ -157,7 +171,6 @@ describe("ifTypeOf() utility", () => {
     const fn2 = (_c: number) => "string";
     const genericFn: Function = () => "string";
 
-
     try {
       const narrow = ifTypeOf(fn).narrowlyExtends(fn2);
       const asWellAsGeneric = ifTypeOf(fn).narrowlyExtends(genericFn);
@@ -172,8 +185,6 @@ describe("ifTypeOf() utility", () => {
     } catch {
       // there is no way to narrow compare functions and so it throws
       // an error to the run time system
-    };
-
+    }
   });
 });
-

package/tests/kv/KeyValue-spec.ts

@@ -1,8 +1,9 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { KeyValue } from "~/types";
+import { KeyValue } from "src/types";
 
 describe("KeyValue<T, K> type utility", () => {
-
   it("explicit KeyValue<T,K> definitions retain literal type info", () => {
     const obj = { foo: 1, bar: "hi", baz: { a: 1, b: 2 } } as const;
     type O = typeof obj;
@@ -13,10 +14,9 @@ describe("KeyValue<T, K> type utility", () => {
     type cases = [
       Expect<Equal<Foo, ["foo", 1]>>,
       Expect<Equal<Bar, ["bar", "hi"]>>,
-      Expect<Equal<Baz, ["baz", { readonly a: 1; readonly b: 2 }]>>,
+      Expect<Equal<Baz, ["baz", { readonly a: 1; readonly b: 2 }]>>
     ];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
   });
-
 });

package/tests/kv/SameKeys-spec.ts

@@ -1,19 +1,17 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect, ExpectFalse } from "@type-challenges/utils";
-import { SameKeys } from "~/types";
+import { SameKeys } from "src/types";
 
 describe("SameKeys<T> utility", () => {
-
   it("keys must be same type but value can be anything", () => {
     const origin = { id: "abc", favorite: false };
     type O = typeof origin;
     type SK = SameKeys<O>;
 
-    type cases = [
-      Expect<Equal<SK, { id: any; favorite: any }>>
-    ];
+    type cases = [Expect<Equal<SK, { id: any; favorite: any }>>];
     const c: cases = [true];
     expect(c).toBe(c);
-
   });
 
   it("explicit assignment does enforce exhaustion of all keys", () => {
@@ -27,12 +25,11 @@ describe("SameKeys<T> utility", () => {
       // does not reach equality
       ExpectFalse<Equal<SameKeys<O>, SameKeys<P>>>,
       // but more importantly P can not be assigned to SameKeys<O>
-      // this ensures that you'd get a type error with: 
+      // this ensures that you'd get a type error with:
       // `const p: SameKeys<O> = { id: "abc" }`
-      ExpectFalse<Equal<SameKeys<O>, P>>,
+      ExpectFalse<Equal<SameKeys<O>, P>>
     ];
     const c: cases = [false, false];
     expect(c).toBe(c);
   });
-
 });

package/tests/kv/dict-to-kv-and-back.spec.ts

@@ -1,13 +1,14 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect, NotEqual } from "@type-challenges/utils";
-import { DictFromKv } from "~/types/kv/DictFromKv";
-import { keys } from "~/utility";
-import { dictToKv, kvToDict } from "~/utility/dictionary/kv";
+import { dictToKv, kvToDict } from "src/utility/dictionary";
+import { DictFromKv } from "src/types/kv";
+import { keys } from "src/utility";
 
 describe("dictToKv()", () => {
   it.skip("basic structure is correct when forcing to Tuple structure", () => {
     const obj = { id: 123, foo: "bar" } as const;
     const val = dictToKv(obj, true);
-    // type Val = typeof val;
 
     expect(Array.isArray(val)).toBeTruthy();
     expect(val).toHaveLength(2);

package/tests/kv/entries-spec.ts

@@ -1,5 +1,7 @@
+import { describe, it, expect } from "vitest";
+
 import type { Expect, NotEqual, Equal, ExpectExtends } from "@type-challenges/utils";
-import { entries } from "~/utility";
+import { entries } from "src/utility";
 
 describe("entries() => ", () => {
   it("literal types are retained", () => {
@@ -25,9 +27,9 @@ describe("entries() => ", () => {
           // inside a conditional, typescript knows as an
           // explicit type and no longer a union of keys
           Expect<Equal<typeof k, "foo">>,
-          // but the value is still a union of all KV 
-          // values which makes it far less valueable
-          Expect<Equal<typeof v, Value>>,
+          // but the value is still a union of all KV
+          // values which makes it far less valuable
+          Expect<Equal<typeof v, Value>>
         ];
         const c: cases2 = [true, true];
         expect(c).toBe(c);
@@ -43,17 +45,14 @@ describe("entries() => ", () => {
     //       // inside a conditional, typescript knows as an
     //       // explicit type and no longer a union of keys
     //       Expect<Equal<typeof entry[0], "foo">>,
-    //       // but the value is still a union of all KV 
-    //       // values which makes it far less valueable
+    //       // but the value is still a union of all KV
+    //       // values which makes it far less valuable
     //       Expect<Equal<typeof v, Value>>,
     //     ];
     //     const c: cases3 = [true, true];
     //     expect(c).toBe(c);
     //   }
     // }
-
-
-
   });
 
   it("values maintain their implicit type even when nested objects", () => {

package/tests/kv/keys.spec.ts

@@ -1,6 +1,8 @@
-import { Keys } from "../../src/types/Keys";
+import { describe, it, expect } from "vitest";
+
+import { Keys } from "src/types/Keys";
 import type { Expect, Equal } from "@type-challenges/utils";
-import { defineType, keys } from "~/utility";
+import { defineType, keys } from "src/utility";
 
 describe("Keys<T>", () => {
   it("Keys<T> is shorthand for keyof T", () => {
@@ -18,9 +20,7 @@ describe("Keys<T>", () => {
     type Arr = typeof arr;
     type MyKeys = Keys<Arr>;
 
-    type cases = [
-      Expect<Equal<MyKeys, "foo" | "bar">>
-    ];
+    type cases = [Expect<Equal<MyKeys, "foo" | "bar">>];
     const cases: cases = [true];
     expect(cases).toBe(cases);
   });
@@ -31,17 +31,13 @@ describe("Keys<T>", () => {
     type OKeys = Keys<typeof obj, "foo">;
     type OArr = Keys<typeof arr, "foo">;
 
-    type cases = [
-      Expect<Equal<OKeys, "bar">>,
-      Expect<Equal<OArr, "bar">>
-    ];
+    type cases = [Expect<Equal<OKeys, "bar">>, Expect<Equal<OArr, "bar">>];
     const cases: cases = [true, true];
     expect(cases).toBe(cases);
   });
 });
 
 describe("keys() utility", () => {
-
   it("with just object passed in, keys are extracted as expected", () => {
     const obj = defineType({ id: "123" })({ color: "red", isFavorite: false });
     const k = keys(obj);
@@ -51,9 +47,7 @@ describe("keys() utility", () => {
     expect(k).toContain("color");
     expect(k).toContain("isFavorite");
 
-    type cases = [
-      Expect<Equal<typeof k, ("color" | "id" | "isFavorite")[]>>
-    ];
+    type cases = [Expect<Equal<typeof k, ("color" | "id" | "isFavorite")[]>>];
     const cases: cases = [true];
     expect(cases).toBe(cases);
   });
@@ -65,12 +59,8 @@ describe("keys() utility", () => {
     expect(k).toHaveLength(1);
     expect(k).toContain("isFavorite");
 
-    type cases = [
-      Expect<Equal<typeof k, ("isFavorite")[]>>
-    ];
+    type cases = [Expect<Equal<typeof k, "isFavorite"[]>>];
     const cases: cases = [true];
     expect(cases).toBe(cases);
   });
-
-
-});
+});

package/tests/kv/kv-spec.ts

@@ -1,7 +1,8 @@
-import { keys, kv } from "~/utility";
+import { describe, it, expect } from "vitest";
 
-describe("kv utils", () => {
+import { keys, kv } from "src/utility";
 
+describe("kv utils", () => {
   it("simple assignment works with strong literal support", () => {
     const t1 = kv("foo", { a: 1, b: 2, c: "hi" });
     const t2 = kv("bar", true);
@@ -16,5 +17,4 @@ describe("kv utils", () => {
     expect(keys(t2)).toContain("bar");
     expect(t2.bar).toBe(true);
   });
-
-});
+});

package/tests/lists/UniqueForProp.spec.ts

@@ -1,5 +1,7 @@
+import { describe, it, expect } from "vitest";
+
 import { Expect, Equal, ExpectExtends } from "@type-challenges/utils";
-import { UniqueForProp } from "~/types/lists";
+import { UniqueForProp } from "src/types/lists";
 
 describe("UniqueForProp<T, P>", () => {
   it("pull off uniques for 'id' prop", () => {

package/tests/literal-spec.ts

@@ -1,4 +1,6 @@
-import { idLiteral, literal } from "~/utility";
+import { describe, it, expect } from "vitest";
+
+import { idLiteral, literal } from "../src/utility";
 import { Equal, NotEqual, Expect, ExpectExtends, ExpectFalse } from "@type-challenges/utils";
 
 describe("literal enforcement", () => {
@@ -57,8 +59,8 @@ describe("literal enforcement", () => {
     /** but with the literal function we can force this to narrow */
     const narrow = literal({ foo: 1, bar: false, baz: "hi" });
     type Narrow = typeof narrow;
-    /** 
-     * would be nice if this worked but it doesn't; once the type is set, it's set 
+    /**
+     * would be nice if this worked but it doesn't; once the type is set, it's set
      */
     const nope = literal(wide);
     type Nope = typeof nope;

package/tests/mapValues-spec.ts

@@ -1,10 +1,12 @@
+import { describe, it, expect } from "vitest";
+
 import { mapValues, literal } from "../src/utility";
 import type { Expect, Equal, ExpectFalse } from "@type-challenges/utils";
 
 describe("mapValues() utility", () => {
   it("simple transform while maintaining wide type through transform", () => {
     const colors = { red: 4, blue: 2, green: 3 };
-    const x2 = mapValues(colors, v => v * 2);
+    const x2 = mapValues(colors, (v) => v * 2);
 
     expect(x2.red).toBe(colors.red * 2);
     expect(x2.blue).toBe(colors.blue * 2);
@@ -25,7 +27,7 @@ describe("mapValues() utility", () => {
 
   it("simple transform but with input type set to literals", () => {
     const colors = literal({ red: 4, blue: 2, green: 3 });
-    const x2 = mapValues(colors, v => v * 2);
+    const x2 = mapValues(colors, (v) => v * 2);
 
     expect(x2.red).toBe(colors.red * 2);
     expect(x2.blue).toBe(colors.blue * 2);
@@ -45,4 +47,4 @@ describe("mapValues() utility", () => {
     const cases: cases = [false, true, true];
     expect(cases).toBe(cases);
   });
-});
+});

package/tests/props-spec.ts

@@ -1,4 +1,5 @@
-/* eslint-disable unicorn/consistent-function-scoping */
+import { describe, it, expect } from "vitest";
+
 import type { Expect, Equal } from "@type-challenges/utils";
 import {
   KeysWithValue,
@@ -11,7 +12,7 @@ import {
   NumericKeys,
   NonStringKeys,
   WithNumericKeys,
-} from "~/types/props";
+} from "src/types/dictionary/props";
 
 type T0 = { foo: number; bar: number; baz: string };
 type T1 = { foo: number; bar: number; baz?: string };

package/tests/runtime/condition.spec.ts

@@ -1,4 +1,5 @@
-import { condition, isFunction, isTrue } from "~/utility";
+import { describe, it, expect } from "vitest";
+import { condition, isFunction, isTrue } from "src/utility";
 
 describe("condition() utility", () => {
   it("basic type checks through condition abstraction", () => {

package/tests/runtime/type.spec.ts

@@ -1,7 +1,8 @@
-/* eslint-disable unicorn/consistent-function-scoping */
+import { describe, it, expect } from "vitest";
+
 import type { Expect, Equal } from "@type-challenges/utils";
-import { FunctionType } from "~/types";
-import { type, createFnWithProps, isFunction, isObject } from "~/utility";
+import { FunctionType } from "src/types";
+import { type, createFnWithProps, isFunction, isObject } from "src/utility";
 
 describe("testing type() utility and some pre-made conditions", () => {
   it("isFunction()", () => {

package/tests/strArrayToDict-spec.ts

@@ -1,6 +1,7 @@
-import { literal, strArrayToDict } from "~/utility";
-import type { Expect, Equal, ExpectFalse } from "@type-challenges/utils";
+import { describe, it } from "vitest";
 
+import { literal, strArrayToDict } from "../src/utility";
+import type { Expect, Equal, ExpectFalse } from "@type-challenges/utils";
 
 describe("strArrayToDict() utility", () => {
   it("", () => {
@@ -29,12 +30,11 @@ describe("strArrayToDict() utility", () => {
       // TODO: see if there's a way to force input to be literal
       ExpectFalse<Equal<R4, { a: true; b: true; c: true }>>,
       // and unfortunately it's lost all track of the keys
-      // which are involved; just knowning that they are 
+      // which are involved; just knowning that they are
       // string based keys
-      Expect<Equal<keyof R4, string>>,
+      Expect<Equal<keyof R4, string>>
     ];
 
     const cases: cases = [true, true, true, false, true];
-
   });
-});
+});

package/tests/string-literals/AllCaps.spec.ts

@@ -1,18 +1,15 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { AllCaps } from "~/types";
+import { AllCaps } from "src/types";
 
 describe("AllCaps<T> type utility", () => {
-
   it("finds AllCaps where it exists", () => {
     type T1 = AllCaps<"YUP">;
     type T2 = AllCaps<"YUP ">;
     type T3 = AllCaps<"YUP YUP YESSSSSSSSSSSSSS">;
 
-    type cases = [
-      Expect<Equal<T1, true>>,
-      Expect<Equal<T2, true>>,
-      Expect<Equal<T3, true>>,
-    ];
+    type cases = [Expect<Equal<T1, true>>, Expect<Equal<T2, true>>, Expect<Equal<T3, true>>];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
   });
@@ -21,10 +18,7 @@ describe("AllCaps<T> type utility", () => {
     type T1 = AllCaps<"Nope">;
     type T2 = AllCaps<"  noo nooo noooooooooooooo">;
 
-    type cases = [
-      Expect<Equal<T1, false>>,
-      Expect<Equal<T2, false>>,
-    ];
+    type cases = [Expect<Equal<T1, false>>, Expect<Equal<T2, false>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -32,11 +26,8 @@ describe("AllCaps<T> type utility", () => {
   it("when passed a non literal string, returns 'unknown'", () => {
     type T1 = AllCaps<string>;
 
-    type cases = [
-      Expect<Equal<T1, "unknown">>,
-    ];
+    type cases = [Expect<Equal<T1, "unknown">>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
-
 });