inferred-types 0.19.0 → 0.22.0

package/src/utility/literals/arrayToObject.ts

@@ -1,22 +1,28 @@
-import { Narrowable } from "~/types/Narrowable";
-
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * **UniqueDictionary**
- * 
+ *
  * A dictionary converted by `arrayToObject()` which expects each key `S` to have a only a
  * single/unique value.
  */
-export type UniqueDictionary<S extends PropertyKey, N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>> = { [V in T as V[S]]: V };
+export type UniqueDictionary<
+  S extends PropertyKey,
+  N extends Narrowable,
+  T extends Record<keyof T, N> & Record<S, any>
+> = { [V in T as V[S]]: V };
 
 /**
  * **GeneralDictionary**
- * 
+ *
  * A dictionary converted by `arrayToObject()` which expects each key `S` to have an
  * array of values.
  */
-export type GeneralDictionary<S extends PropertyKey, N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>> = { [V in T as V[S]]: V[] };
-
+export type GeneralDictionary<
+  S extends PropertyKey,
+  N extends Narrowable,
+  T extends Record<keyof T, N> & Record<S, any>
+> = { [V in T as V[S]]: V[] };
 
 export type ArrayConverter<S extends PropertyKey, U extends boolean> =
   /**
@@ -28,45 +34,40 @@ export type ArrayConverter<S extends PropertyKey, U extends boolean> =
     arr: readonly T[]
   ) => true extends U ? UniqueDictionary<S, N, T> : GeneralDictionary<S, N, T>;
 
-
 /**
  * Converts an array of objects into a dictionary by picking a property name contained
  * by all objects and using that as the key to the dictionary.
- * 
+ *
  * ```ts
- * const arr = [ 
+ * const arr = [
  *   { kind: "color", favorite: "blue", likes: 100 },
  *   { kind: "song", favorite: "some song", likes: 25 }
  * ];
  * const dict = arrayToObject("kind")(arr);
  * ```
- * 
+ *
  * This will produce a dictionary with keys of `color` and `song`.
  */
-export function arrayToObject<
-  S extends PropertyKey,
-  U extends boolean
->(prop: S, unique?: U) {
+export function arrayToObject<S extends PropertyKey, U extends boolean>(prop: S, unique?: U) {
   type X = true extends U ? true : false;
   /**
    * **arrayToObject** - partially applied
-   * 
+   *
    * pass in an array of objects to complete application of arrayToObject()
    */
-  const transform: ArrayConverter<S, X> = <N extends Narrowable, T extends Record<keyof T, N> & Record<S, any>>(
+  const transform: ArrayConverter<S, X> = <
+    N extends Narrowable,
+    T extends Record<keyof T, N> & Record<S, any>
+  >(
     arr: readonly T[]
   ): true extends X ? UniqueDictionary<S, N, T> : GeneralDictionary<S, N, T> => {
-
-    const result = unique !== false
-      ? arr.reduce(
-        (acc, v) => ({ ...acc, [v[prop]]: v }), {} as UniqueDictionary<S, N, T>
-      )
-      : arr.reduce(
-        (acc, v) => {
-          const existing = acc[v[prop] as T[S]] || [];
-          return { ...acc, [v[prop]]: [...existing, v] };
-        }, {} as GeneralDictionary<S, N, T>
-      );
+    const result =
+      unique !== false
+        ? arr.reduce((acc, v) => ({ ...acc, [v[prop]]: v }), {} as UniqueDictionary<S, N, T>)
+        : arr.reduce((acc, v) => {
+            const existing = acc[v[prop] as T[S]] || [];
+            return { ...acc, [v[prop]]: [...existing, v] };
+          }, {} as GeneralDictionary<S, N, T>);
 
     // type cast based on `U`
     return result as true extends X ? UniqueDictionary<S, N, T> : GeneralDictionary<S, N, T>;
@@ -75,4 +76,3 @@ export function arrayToObject<
   return transform;
   // return converter(prop, unique);
 }
-

package/src/utility/literals/defineType.ts

@@ -1,15 +1,15 @@
-import { ExpandRecursively, Narrowable } from "~/types";
+import { ExpandRecursively } from "src/types/ExpandRecursively";
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * Build a _type_ from two run-time dictionaries.
- * 
+ *
  * 1. The _first_ -- which is optional -- is interpreted as a _literal_ type definition
  * 2. The _second_ dictionary is interpreted as a "wide" definition of prop types
  */
-export function defineType<
-  N extends Narrowable,
-  TLiteral extends Record<string, N>
->(literal: TLiteral = {} as TLiteral) {
+export function defineType<N extends Narrowable, TLiteral extends Record<string, N>>(
+  literal: TLiteral = {} as TLiteral
+) {
   /**
    * Add any key/value pairs which you want to have _wide_ types associated;
    * literal types are defined already and stated above.

package/src/utility/literals/identity.ts

@@ -1,4 +1,5 @@
-import { Narrowable } from "~/types/Narrowable";
+import { Narrowable } from "src/types/Narrowable";
+
 /**
  * An identity function for any type, with the goal of preserving literal type information
  * whereever possible.
@@ -6,4 +7,6 @@ import { Narrowable } from "~/types/Narrowable";
 export const identity = <
   N extends Narrowable,
   T extends Record<any, N> | number | string | boolean | symbol | undefined | null
->(v: T) => v;
+>(
+  v: T
+) => v;

package/src/utility/literals/literal.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-use-before-define */
 
-import { Narrowable } from "~/types";
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * Takes an object as input --which has an `id` property and returns it as the same
@@ -39,8 +39,8 @@ export function idTypeGuard<T extends { id: I }, I extends PropertyKey>(
 /**
  * Takes an object as input and infers the narrow literal types of the property
  * values on the object.
- * 
- * > Note: this addresses this [a known TS gap](https://github.com/microsoft/TypeScript/issues/30680). 
+ *
+ * > Note: this addresses this [a known TS gap](https://github.com/microsoft/TypeScript/issues/30680).
  * > Hopefully at some point this will be addressed in the language.
  */
 export function literal<N extends Narrowable, T extends Record<keyof T, N>>(obj: T) {

package/src/utility/ruleset.ts

@@ -1,5 +1,6 @@
 /* eslint-disable no-use-before-define */
-import type { Narrowable } from "~/types";
+
+import { Narrowable } from "src/types/Narrowable";
 
 // TODO: get ruleset functionality working!
 
@@ -15,21 +16,23 @@ import type { Narrowable } from "~/types";
 
 /**
  * **ruleSet**
- * 
+ *
  * Defines a ruleset composed of _dynamic_ and _static_ boolean operators.
- * 
+ *
  * - the first function call defines _dynamic_ props (_optional_)
  * - the second function call defines static values
- * 
+ *
  * ```ts
- * const rs = ruleSet( 
+ * const rs = ruleSet(
  *    r => r.state()( { maybe: r => r.extends({ foo: 1 }) })
- * )( 
- *    { color: true, age: false } 
+ * )(
+ *    { color: true, age: false }
  * );
  * ```
  */
-export function ruleSet<N extends Narrowable, TState extends Record<keyof TState, N>>(defn?: TState) {
+export function ruleSet<N extends Narrowable, TState extends Record<keyof TState, N>>(
+  defn?: TState
+) {
   // return <
   //   TStatic extends { [K in keyof TStatic]: Readonly<true | false> },
   //   >(rules: TStatic) => {
@@ -37,4 +40,3 @@ export function ruleSet<N extends Narrowable, TState extends Record<keyof TState
   // };
   return defn;
 }
-

package/src/utility/runtime/condition.ts

@@ -1,4 +1,4 @@
-import { Narrowable } from "~/types";
+import { Narrowable } from "src/types/Narrowable";
 
 export type Condition<TInput extends Narrowable, TResult extends boolean> = (
   input: TInput

package/src/utility/runtime/conditions/isFalse.ts

@@ -1,5 +1,5 @@
-import { Narrowable } from "~/types";
-import { IsBoolean } from "~/utility";
+import { Narrowable } from "src/types/Narrowable";
+import { IsBoolean } from "./isBoolean";
 
 export type IsFalse<T extends Narrowable> = IsBoolean<T> extends true
   ? // is a boolean

package/src/utility/runtime/conditions/isFunction.ts

@@ -1,4 +1,4 @@
-import { FunctionType } from "~/types";
+import { FunctionType } from "src/types/FunctionType";
 
 export type IsFunction<T> = T extends FunctionType ? true : false;
 
@@ -11,7 +11,7 @@ export type IsFunction<T> = T extends FunctionType ? true : false;
  * ```
  *
  * Note: the runtime `typeof [variable]` will correctly say "function" when a function is
- * encounted but if that function also has object types defined then the type will be a big
+ * encountered but if that function also has object types defined then the type will be a big
  * and ugly union type. This function will give you a proper boolean value in both cases.
  */
 export function isFunction<T extends unknown>(input: T): IsFunction<T> {

package/src/utility/runtime/conditions/isObject.ts

@@ -1,4 +1,7 @@
-import { FunctionType, Mutable, Narrowable, Not } from "~/types";
+import { FunctionType } from "src/types/FunctionType";
+import { Mutable } from "src/types/Mutable";
+import { Narrowable } from "src/types/Narrowable";
+import { Not } from "src/types/Not";
 
 export type IsObject<T> = Mutable<T> extends Record<string, any>
   ? // an object of some type

package/src/utility/runtime/conditions/isTrue.ts

@@ -1,4 +1,4 @@
-import { Narrowable } from "~/types";
+import { Narrowable } from "src/types/Narrowable";
 import type { IsBoolean } from "./isBoolean";
 
 /**

package/src/utility/runtime/ifTypeOf.ts

@@ -1,4 +1,4 @@
-import { Narrowable } from "~/types/Narrowable";
+import { Narrowable } from "src/types/Narrowable";
 import { keys } from "../keys";
 
 function runtimeExtendsCheck<TValue extends any, TBase extends any>(

package/src/utility/runtime/type.ts

@@ -1,4 +1,6 @@
-import { FunctionType, Narrowable, TypeGuard } from "~/types";
+import { FunctionType } from "src/types/FunctionType";
+import { Narrowable } from "src/types/Narrowable";
+import { TypeGuard } from "src/types/TypeGuard";
 import {
   isString,
   isBoolean,

package/src/utility/runtime/withValue.ts

@@ -1,8 +1,10 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
-import { ExpandRecursively, Narrowable, WithValue } from "~/types";
-import { entries } from "~/utility/dictionary";
-import { type, TypeDefinition } from "~/utility/runtime";
+import { WithValue } from "src/types/dictionary";
+import { ExpandRecursively } from "src/types/ExpandRecursively";
+import { Narrowable } from "src/types/Narrowable";
+import { entries } from "../dictionary/entries";
+import { type, TypeDefinition } from "./type";
 
 /**
  * **withValue**

package/src/utility/state/Configurator.ts

@@ -1,4 +1,5 @@
-/* eslint-disable unicorn/consistent-function-scoping */
+import { ExpandRecursively } from "src/types/ExpandRecursively";
+
 type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 function omit<T extends {}, K extends Array<keyof T>>(obj: T, ...removals: K) {
   const untyped = removals as Array<unknown>;
@@ -8,7 +9,6 @@ function omit<T extends {}, K extends Array<keyof T>>(obj: T, ...removals: K) {
   >;
 }
 
-import { ExpandRecursively } from "~/types";
 export interface IConfigurator<C = {}> {
   set<V, K extends string, KV = { [U in K]: V }>(
     key: K,

package/src/utility/state/FluentConfigurator.ts

@@ -1,4 +1,4 @@
-import type { ExpandRecursively } from "~/types";
+import { ExpandRecursively } from "src/types/ExpandRecursively";
 
 export interface IFluentConfigurator<C> {
   /**
@@ -28,7 +28,7 @@ export function FluentConfigurator<I>(initial: I = {} as I) {
   const api = <C>(current: C): IFluentConfigurator<C> => {
     return {
       set<V, K extends string, KV = { [U in K]: V }>(key: K, value: V) {
-        const keyValue = ({ [key]: value as V } as unknown) as KV;
+        const keyValue = { [key]: value as V } as unknown as KV;
         const updated = { ...keyValue, ...current };
 
         return api<C & KV>(updated);

package/src/utility/state/index.ts

@@ -1,12 +1,11 @@
 // #autoindex
 // #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: fd5dfde8
+// index last changed at: 7th Jul, 2022, 01:15 PM ( GMT-7 )
+// hash-code: 14769606
 
 // file exports
 export * from "./Configurator";
 export * from "./FluentConfigurator";
-export * from "./KeyStorage";
 
 // #endregion
 

package/tests/CamelCase-spec.ts

@@ -1,3 +1,5 @@
+import { describe, it, expect } from "vitest";
+
 import { CamelCase } from "../src/types";
 import { Expect, Equal } from "@type-challenges/utils";
 

package/tests/ExplicitFunction-spec.ts

@@ -1,5 +1,6 @@
-/* eslint-disable unicorn/consistent-function-scoping */
-import { ExplicitFunction } from "~/utility";
+import { describe, it, expect } from "vitest";
+
+import { ExplicitFunction } from "../src/utility";
 import type { Expect, Equal } from "@type-challenges/utils";
 
 describe("ExplicitFunction()", () => {

package/tests/IncludeAndRetain-spec.ts

@@ -1,4 +1,6 @@
-import { Include, Retain } from "~/types";
+import { describe, it, expect } from "vitest";
+
+import { Include, Retain } from "../src/types";
 import { Equal, Expect } from "@type-challenges/utils";
 
 // INCLUDE
@@ -8,10 +10,7 @@ describe("Include<T, U> utility", () => {
     type Foo = Include<typeof str, string>;
     type NotFoo = Include<typeof str, number>;
 
-    type cases = [
-      Expect<Equal<Foo, "foo">>,
-      Expect<Equal<NotFoo, never>>
-    ];
+    type cases = [Expect<Equal<Foo, "foo">>, Expect<Equal<NotFoo, never>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -33,12 +32,11 @@ describe("Include<T, U> utility", () => {
       Expect<Equal<RelatedFoo, "foo">>,
       // this behavior is adjusted if you include
       // the optional `L` generic as a true value
-      Expect<Equal<NotLiteralFoo, never>>,
+      Expect<Equal<NotLiteralFoo, never>>
     ];
     const c: cases = [true, true, true, true];
     expect(c).toBe(c);
   });
-
 });
 
 // RETAIN
@@ -52,7 +50,7 @@ describe("Retain<T, U> utility", () => {
     type cases = [
       Expect<Equal<FooBar, { foo: number; bar: number }>>,
       Expect<Equal<Baz, { baz: string }>>,
-      Expect<Equal<FooBaz, { foo: number; baz: string }>>,
+      Expect<Equal<FooBaz, { foo: number; baz: string }>>
     ];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
@@ -62,11 +60,8 @@ describe("Retain<T, U> utility", () => {
     type Obj = { foo: 1; bar?: number; baz: "hi" };
     type FooBar = Retain<Obj, "foo" | "bar">;
 
-    type cases = [
-      Expect<Equal<FooBar, { foo: 1; bar?: number }>>,
-    ];
+    type cases = [Expect<Equal<FooBar, { foo: 1; bar?: number }>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
-
 });

package/tests/Includes-spec.ts

@@ -1,3 +1,5 @@
+import { describe, it, expect } from "vitest";
+
 import type { Includes } from "../src/types";
 import type { ExpectTrue, ExpectFalse } from "@type-challenges/utils";
 

package/tests/KebabCase-spec.ts

@@ -1,3 +1,5 @@
+import { describe, it } from "vitest";
+
 import type { KebabCase } from "../src/types";
 import type { Expect, Equal } from "@type-challenges/utils";
 

package/tests/MutationIdentity-spec.ts

@@ -1,4 +1,5 @@
-/* eslint-disable unicorn/consistent-function-scoping */
+import { describe, it, expect } from "vitest";
+
 import { MutationIdentity } from "../src/Mutation";
 import type { Expect, Equal, ExpectExtends } from "@type-challenges/utils";
 

package/tests/PascalCase-spec.ts

@@ -1,3 +1,5 @@
+import { describe, it, expect } from "vitest";
+
 import type { PascalCase } from "../src/types";
 import type { Expect, Equal } from "@type-challenges/utils";
 

package/tests/Pluralize-spec.ts

@@ -1,3 +1,5 @@
+import { describe, it } from "vitest";
+
 import type { Pluralize } from "../src/types";
 import type { Expect, Equal } from "@type-challenges/utils";
 

package/tests/SnakeCase-spec.ts

@@ -1,3 +1,5 @@
+import { describe, it } from "vitest";
+
 import { SnakeCase } from "../src/types";
 import { Expect, Equal } from "@type-challenges/utils";
 

package/tests/Where.spec.ts

@@ -1,8 +1,9 @@
+import { describe, it, expect } from "vitest";
+
 import { Expect, Equal } from "@type-challenges/utils";
 import { Where, WhereNot } from "../src/types/Where";
 
 describe("Where<T,U> and WhereNot<T,U> type utility", () => {
-
   it("readonly string array works correctly", () => {
     const arr = ["foo", "bar", "baz"] as const;
     type A = typeof arr;
@@ -11,29 +12,27 @@ describe("Where<T,U> and WhereNot<T,U> type utility", () => {
 
     type cases = [
       //
-      Expect<Equal<B, "bar"| "baz">>,
+      Expect<Equal<B, "bar" | "baz">>,
       Expect<Equal<F, "foo">>
     ];
-    
-    const c: cases = [ true, true ];
+
+    const c: cases = [true, true];
     expect(c).toBe(c);
   });
 
   it("object with literal keys works", () => {
-    const arr = {foo: true, bar: true, baz: true} as const;
+    const arr = { foo: true, bar: true, baz: true } as const;
     type A = typeof arr;
     type B = Where<A, `ba${string}`>;
     type F = WhereNot<A, `ba${string}`>;
 
     type cases = [
       //
-      Expect<Equal<B, "bar"| "baz">>,
+      Expect<Equal<B, "bar" | "baz">>,
       Expect<Equal<F, "foo">>
     ];
-    
-    const c: cases = [ true, true ];
+
+    const c: cases = [true, true];
     expect(c).toBe(c);
   });
-
-
 });

package/tests/arrayToKeyLookup-spec.ts

@@ -1,5 +1,7 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { arrayToKeyLookup } from "~/utility";
+import { arrayToKeyLookup } from "../src/utility";
 
 describe("arrayToKeyLookup()", () => {
   it("simple string array is converted", () => {
@@ -8,10 +10,8 @@ describe("arrayToKeyLookup()", () => {
     expect(lookup.bar).toBe(true);
     expect(lookup.baz).toBe(true);
 
-    type cases = [
-      Expect<Equal<typeof lookup, Record<"foo" | "bar" | "baz", true>>>
-    ];
+    type cases = [Expect<Equal<typeof lookup, Record<"foo" | "bar" | "baz", true>>>];
     const cases: cases = [true];
     expect(cases).toBe(cases);
   });
-});
+});

package/tests/arrayToObject-spec.ts

@@ -1,15 +1,21 @@
+import { describe, it, expect } from "vitest";
 
 import { Equal, Expect, ExpectExtends } from "@type-challenges/utils";
-import { ArrayConverter, arrayToObject, GeneralDictionary, UniqueDictionary, defineType, keys } from "~/utility";
+import {
+  ArrayConverter,
+  arrayToObject,
+  GeneralDictionary,
+  UniqueDictionary,
+  defineType,
+  keys,
+} from "../src/utility";
 
 const foo = { name: "foo", age: 123, color: "red" } as const;
 const foo2 = { name: "foo", age: 44, color: "orange" } as const;
 const bar = { name: "bar", age: 456, color: "blue" } as const;
 const baz = { name: "baz", age: 42, color: "green" } as const;
 
-
 describe("arrayToObject => ", () => {
-
   it("partial application of arrayToObject()", () => {
     const t1 = arrayToObject("name", false);
     type T1 = typeof t1;
@@ -28,7 +34,7 @@ describe("arrayToObject => ", () => {
       // The response types for each type is as expected
       Expect<ExpectExtends<GeneralDictionary<"name", any, any>, ReturnType<T1>>>,
       Expect<ExpectExtends<UniqueDictionary<"name", any, any>, ReturnType<T2>>>,
-      Expect<ExpectExtends<UniqueDictionary<"name", any, any>, ReturnType<T3>>>,
+      Expect<ExpectExtends<UniqueDictionary<"name", any, any>, ReturnType<T3>>>
     ];
 
     const cases: cases = [true, true, true, true, true, true];
@@ -71,7 +77,7 @@ describe("arrayToObject => ", () => {
       // however when we passed in two "types" for "foo" we get a union
       Expect<Equal<typeof dict2["foo"], SomeFoo>>,
       // once we state that foo is not unique, the type expanded to an array
-      Expect<Equal<typeof dict3["foo"], SomeFoo[]>>,
+      Expect<Equal<typeof dict3["foo"], SomeFoo[]>>
     ];
     const cases: cases = [true, true, true, true, true];
     expect(cases).toBe(cases);
@@ -100,12 +106,10 @@ describe("arrayToObject => ", () => {
       Expect<Equal<Slug["bob"]["slug"], "bob">>,
       // "age" and "color" are expressed as their widened types
       Expect<Equal<Id["1"]["age"], number>>,
-      Expect<Equal<Id["1"]["color"], string>>,
+      Expect<Equal<Id["1"]["color"], string>>
     ];
 
     const cases: cases = [true, true, true, true, true, true];
     expect(cases).toBe(cases);
   });
-
-
 });

package/tests/constructor.spec.ts

@@ -1,3 +1,5 @@
+import { describe, it, expect } from "vitest";
+
 import { Expect, Equal } from "@type-challenges/utils";
 import { Constructor } from "../src/types/Constructor";
 

package/tests/createFnWithProps.spec.ts

@@ -1,5 +1,5 @@
-/* eslint-disable unicorn/consistent-function-scoping */
-import { createFnWithProps } from "~/index";
+import { describe, it, expect } from "vitest";
+import { createFnWithProps } from "../src/index";
 
 describe("createFnWithProps()", () => {
   it("simple fn and prop are combined, type is retained", () => {

package/tests/defineType-spec.ts

@@ -1,7 +1,8 @@
-import type { Expect, Equal } from "@type-challenges/utils";
-import { ExpectExtends } from "~/types";
-import { defineType } from "~/utility";
+import { describe, it, expect } from "vitest";
 
+import type { Expect, Equal } from "@type-challenges/utils";
+import { ExpectExtends } from "../src/types";
+import { defineType } from "../src/utility";
 
 describe("inferredType() utility", () => {
   it("only specify a wide type", () => {
@@ -22,7 +23,16 @@ describe("inferredType() utility", () => {
       Expect<Equal<typeof t, { foo: string; bar: number }>>,
       // for some odd reason, when we let the default value for literal
       // we get something odd
-      Expect<Equal<typeof t2, { foo: string; bar: number;[x: string]: string | number | boolean | symbol | void | object | {} | null | undefined }>>,
+      Expect<
+        Equal<
+          typeof t2,
+          {
+            foo: string;
+            bar: number;
+            [x: string]: string | number | boolean | symbol | void | object | {} | null | undefined;
+          }
+        >
+      >,
       // fortunately it does extend the intended type
       Expect<ExpectExtends<typeof t2, { foo: string; bar: number }>>
     ];
@@ -32,9 +42,7 @@ describe("inferredType() utility", () => {
 
   it("only specify a literal type", () => {
     const t = defineType({ foo: 1, bar: "hi" })();
-    type cases = [
-      Expect<Equal<typeof t, { foo: 1; bar: "hi" }>>
-    ];
+    type cases = [Expect<Equal<typeof t, { foo: 1; bar: "hi" }>>];
     const cases: cases = [true];
     expect(cases).toBe(cases);
   });
@@ -42,10 +50,8 @@ describe("inferredType() utility", () => {
   it("specify both wide and literal merged type", () => {
     const t = defineType({ bar: 1 })({ foo: "" });
 
-    type cases = [
-      Expect<Equal<typeof t, { foo: string; bar: 1 }>>
-    ];
+    type cases = [Expect<Equal<typeof t, { foo: string; bar: 1 }>>];
     const cases: cases = [true];
     expect(cases).toBe(cases);
   });
-});
+});