inferred-types 0.37.0 → 0.37.1

package/tests/dictionaryTransform-spec.ts

@@ -1,280 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { dictionaryTransform, ExplicitFunction } from "../src/runtime";
-import { Expect, Equal, NotEqual, ExpectExtends, ExpectFalse } from "@type-challenges/utils";
-import { ToFluent, Transformer } from "../src/types";
-
-describe("dictionaryTransform()", () => {
-  type A = { foo: string; bar: string };
-  const a: A = { foo: "1", bar: "2" };
-  type F = { foo: () => string; bar: () => string };
-  const f: F = { foo: () => "1", bar: () => "2" };
-  type F2 = { foo: (n: number) => string; bar: (a: number, b: number) => string };
-  // const f2: F2 = { foo: (n: number) => `${n}`, bar: (a: number, b: number) => `${a * b}` };
-
-  // B typed
-  type B = { foo: number; bar: number };
-  // B typed as literal
-  type BL = { foo: 1; bar: 2 };
-  const b = { foo: 1, bar: 2 };
-  // B inferred
-  type BI = typeof b;
-
-  const createMutationApi = (state: { foo: number }) => {
-    const api = {
-      increment() {
-        return { ...state, foo: state.foo + 1 };
-      },
-      decrement() {
-        return { ...state, foo: state.foo - 1 };
-      },
-      set(v: number) {
-        return { ...state, foo: v };
-      },
-
-      getState() {
-        return state;
-      },
-    };
-
-    return api;
-  };
-
-  type State = { foo: number };
-  const state: State = { foo: 0 };
-
-  type MutApi = { inc: () => State; dec: () => State; set: (n: number) => State };
-  const mutApi: MutApi = {
-    inc() {
-      return { ...state, foo: state.foo + 1 };
-    },
-    dec() {
-      return { ...state, foo: state.foo - 1 };
-    },
-    set(n: number) {
-      return { ...state, foo: n };
-    },
-  };
-  type FluentApi = { inc: () => FluentApi; dec: () => FluentApi; set: (n: number) => FluentApi };
-  const fluentApi: FluentApi = {
-    inc() {
-      state.foo = mutApi.inc().foo;
-      return fluentApi;
-    },
-    dec() {
-      state.foo = mutApi.dec().foo;
-      return fluentApi;
-    },
-    set(n: number) {
-      state.foo = mutApi.set(n).foo;
-      return fluentApi;
-    },
-  };
-  type SyntheticFluent = ToFluent<MutApi>;
-
-  it("simple dictionary with strings converted to numbers", () => {
-    const transform: Transformer<A, B> = (i, k) => {
-      return Number(i[k]);
-    };
-
-    const t = dictionaryTransform(a, transform);
-    type T = typeof t;
-
-    type cases = [
-      // wide type of string should now be number
-      Expect<Equal<T, B>>,
-      Expect<Equal<T, BI>>,
-      Expect<ExpectExtends<T, B>>,
-      Expect<ExpectExtends<T, BI>>,
-      // literals will not be involved here
-      Expect<NotEqual<T, BL>>,
-      // the literal _does_ extend the wider type
-      Expect<ExpectExtends<T, BL>>,
-      // but not the reverse
-      ExpectFalse<ExpectExtends<BL, T>>
-    ];
-
-    const cases: cases = [true, true, true, true, true, true, false];
-    expect(cases).toBe(cases);
-  });
-
-  it("simple function based dictionary <F> converted to numbers <B>", () => {
-    const transform: Transformer<F, B> = (i, k) => {
-      return Number(i[k]());
-    };
-    const t = dictionaryTransform(f, transform);
-    type T = typeof t;
-
-    type cases = [
-      // wide type of string should now be number
-      Expect<Equal<T, B>>,
-      Expect<Equal<T, BI>>,
-      Expect<ExpectExtends<T, B>>,
-      Expect<ExpectExtends<T, BI>>,
-      // literals will not be involved here
-      Expect<NotEqual<T, BL>>,
-      // the literal _does_ extend the wider type
-      Expect<ExpectExtends<T, BL>>,
-      // but not the reverse
-      ExpectFalse<ExpectExtends<BL, T>>
-    ];
-
-    const cases: cases = [true, true, true, true, true, true, false];
-    expect(cases).toBe(cases);
-  });
-
-  it("function with variant parameters <F2> converted to numbers <B>", () => {
-    const transform: Transformer<F2, B> = (i, k) => {
-      switch (k) {
-        case "foo":
-          return Number(i[k](4));
-        case "bar":
-          return Number(i[k](1, 2));
-      }
-    };
-    const t = dictionaryTransform(f, transform);
-    type T = typeof t;
-
-    type cases = [
-      // wide type of string should now be number
-      Expect<Equal<T, B>>,
-      Expect<Equal<T, BI>>,
-      Expect<ExpectExtends<T, B>>,
-      Expect<ExpectExtends<T, BI>>,
-      // literals will not be involved here
-      Expect<NotEqual<T, BL>>,
-      // the literal _does_ extend the wider type
-      Expect<ExpectExtends<T, BL>>,
-      // but not the reverse
-      ExpectFalse<ExpectExtends<BL, T>>
-    ];
-
-    const cases: cases = [true, true, true, true, true, true, false];
-    expect(cases).toBe(cases);
-  });
-
-  it("A mutation function can can be transformed into a fluent API", () => {
-    const state = { foo: 0 };
-    const api = createMutationApi(state);
-    type A = typeof api;
-    // the mutation api performs as expected
-    // this includes returning the state after any call
-    expect(api.increment().foo).toBe(1);
-    expect(api.decrement().foo).toBe(-1);
-    // the one exception is getState which just returns the value
-    expect(api.getState().foo).toBe(0);
-
-    // transform function
-    const transform: Transformer<A, ToFluent<A>> = (i, k) => {
-      switch (k) {
-        case "getState":
-          return () => {
-            return dictionaryTransform(api, transform);
-          };
-        case "set":
-        case "decrement":
-        case "increment":
-          const fn = ExplicitFunction(i[k]);
-          return (...args: Parameters<typeof fn>) => {
-            fn(...args);
-            // this is cheating as runtime is not updated
-            return dictionaryTransform(api, transform);
-          };
-      }
-    };
-
-    const t = dictionaryTransform(api, transform);
-    type T = typeof t;
-
-    // the transformed API is fluent and so calls to the API should return
-    // the same API surface
-    expect(typeof t.increment().increment).toBe("function");
-    expect(typeof t.decrement().increment).toBe("function");
-    // this even applies to getState() which no longer has any useful utility
-    expect(typeof t.getState().increment).toBe("function");
-    // this pattern should continue indefinitely
-    expect(typeof t.increment().decrement().increment().decrement).toBe("function");
-
-    // beyond the run-time system, we must check that all types are expected
-    type cases = [
-      // All functions return the same API defined by T
-      Expect<Equal<ReturnType<T["increment"]>, T>>,
-      Expect<Equal<ReturnType<T["decrement"]>, T>>,
-      Expect<Equal<ReturnType<T["set"]>, T>>,
-      Expect<Equal<ReturnType<T["getState"]>, T>>,
-      // set() has a distinct set of parameters from other methods
-      Expect<NotEqual<Parameters<T["increment"]>, Parameters<T["set"]>>>,
-      // whereas the rest on this API are the same
-      Expect<Equal<Parameters<T["increment"]>, Parameters<T["decrement"]>>>
-    ];
-    const cases: cases = [true, true, true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("Explicit mutation API and fluent API", () => {
-    const transform: Transformer<MutApi, FluentApi> = (i, k) => {
-      switch (k) {
-        case "dec":
-        case "inc":
-          return () => {
-            i[k](); // mutate state
-            return fluentApi;
-          };
-        case "set":
-          return (n: number) => {
-            i[k](n); // mutate state
-            return fluentApi;
-          };
-      }
-    };
-
-    const t = dictionaryTransform(mutApi, transform);
-    type T = typeof t;
-
-    type cases = [
-      // the explicit definition of the Fluent API is
-      // the same as the synthetic version created with ToFluent
-      Expect<Equal<FluentApi, SyntheticFluent>>,
-      // the fluent API derived from the dictionary transform is
-      // also the same as the explicit and synthetic
-      Expect<Equal<FluentApi, T>>
-    ];
-    const cases: cases = [true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("using dictionaryTransform recursively for fluent API works at both runtime and designtime", () => {
-    const transform: Transformer<MutApi, FluentApi> = (i, k) => {
-      switch (k) {
-        case "dec":
-        case "inc":
-          return () => {
-            state.foo = i[k]().foo; // mutate state, assign to global "state"
-            return dictionaryTransform(mutApi, transform);
-          };
-        case "set":
-          return (n: number) => {
-            state.foo = i[k](n).foo; // mutate state
-            return dictionaryTransform(mutApi, transform);
-          };
-      }
-    };
-
-    const t = dictionaryTransform(mutApi, transform);
-    type T = typeof t;
-
-    type cases = [
-      // the fluent API derived from recursive calls to dictionaryTransform
-      // is seen as the same type the explictly deinfined type.
-      Expect<Equal<FluentApi, T>>
-    ];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-
-    t.set(0);
-    expect(state.foo).toBe(0);
-    t.set(1);
-    expect(state.foo).toBe(1);
-    t.set(0).inc().inc();
-    expect(state.foo).toBe(2);
-  });
-});

package/tests/ifTypeOf-spec.ts

@@ -1,191 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { Expect, Equal } from "@type-challenges/utils";
-import { defineType, literal } from "../src/runtime";
-import { ifTypeOf } from "src/runtime/type-checks/ifTypeOf";
-
-describe("ifTypeOf() utility", () => {
-  it("base validation with extends() returns true/false", () => {
-    const target = { foo: "", bar: 0 };
-    const yup = ifTypeOf({ foo: "foo", bar: 42 }).extends(target);
-    const nope = ifTypeOf({ foo: "foo", bar: "whoops" }).extends(target);
-
-    expect(yup).toBe(true);
-    expect(nope).toBe(false);
-
-    type cases = [Expect<Equal<typeof yup, true>>, Expect<Equal<typeof nope, false>>];
-    const cases: cases = [true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("base validation of narrowlyExtends() returns true/false", () => {
-    const target = defineType({ bar: 0 })({ foo: "foo" });
-    const yup = ifTypeOf({ foo: "foo", bar: 0 }).extends(target);
-    const yup2 = ifTypeOf({ foo: "foey", bar: 0 }).extends(target);
-    const nope1 = ifTypeOf({ foo: "foo", bar: 42 }).narrowlyExtends(target);
-    const nope2 = ifTypeOf({ foo: "foo", bar: "whoops" }).extends(target);
-
-    expect(yup).toBe(true);
-    expect(yup2).toBe(true);
-    expect(nope1).toBe(false);
-    expect(nope2).toBe(false);
-
-    type cases = [
-      Expect<Equal<typeof yup, true>>,
-      Expect<Equal<typeof yup2, true>>,
-      Expect<Equal<typeof nope1, false>>,
-      Expect<Equal<typeof nope2, false>>
-    ];
-    const cases: cases = [true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("validation of non-dictionary types works as expected too", () => {
-    const target = 42 as number;
-    const t2 = literal(42);
-
-    const numToNum = ifTypeOf(55).extends(target);
-    const wideNumCompare = ifTypeOf(0).extends(target);
-    const narrowEquality = ifTypeOf(42).narrowlyExtends(t2);
-    const stringIsNumber = ifTypeOf("foo").extends(target);
-    const diffNumbersNarrowly = ifTypeOf(12).narrowlyExtends(t2);
-
-    expect(numToNum).toBe(true);
-    expect(wideNumCompare).toBe(true);
-    expect(narrowEquality).toBe(true);
-    expect(stringIsNumber).toBe(false);
-    expect(diffNumbersNarrowly).toBe(false);
-
-    type cases = [
-      Expect<Equal<typeof numToNum, true>>,
-      Expect<Equal<typeof wideNumCompare, true>>,
-      Expect<Equal<typeof narrowEquality, true>>,
-      Expect<Equal<typeof stringIsNumber, false>>,
-      Expect<Equal<typeof diffNumbersNarrowly, false>>
-    ];
-    const cases: cases = [true, true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("validation of function types works when expressed widely", () => {
-    const target: Function = () => "";
-    const fn = () => "hi";
-    const fnExtends = ifTypeOf(fn).extends(target);
-
-    expect(fnExtends).toBe(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,
-    });
-
-    // completely wrong
-    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);
-
-    // 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);
-
-    // run-time tests of False Positives
-    // ---------------------------------
-    expect(noFoodOrDrink).toBe(false);
-    expect(ready).toBe(true);
-
-    // here we'll show how narrow types need to be
-    // made explicit to both type and run time systems
-
-    // in "fullyBaked" both run-time and type system are wrong functionally
-    // but they report as true
-    expect(fullyBaked).toBe(true);
-    // we can get to a half-way house by expressing the type as "as const" and making it's types
-    // literals; now the type system report "false" and the runtime says "true"
-    expect(halfBaked).toBe(true);
-    // to get to a fully working solution we need to use the `narrowlyDefines` operator
-    // along with the "as const" for the type system
-    expect(lucid).toBe(false);
-
-    // type tests
-    type FalsePositives = [
-      Expect<Equal<typeof noFoodOrDrink, false>>,
-      Expect<Equal<typeof fullyBaked, true>>,
-      Expect<Equal<typeof halfBaked, false>>,
-      Expect<Equal<typeof lucid, false>>
-    ];
-    const falsePositives: FalsePositives = [true, true, true, true];
-    expect(falsePositives).toBe(falsePositives);
-
-    // but now we have to accept that the type might be a combination of both
-    // literal types and broader types; this is not hard to express with types
-    // but it makes our approach much more awkward and the API much more cumbersome
-
-    // here we see a type that represents this challenge but how it fails with
-    // with the runtime
-
-    const literal = { foo: 1 } as const;
-    const wide = { bar: "hi" };
-    const hybrid = { ...literal, ...wide };
-    const toughLuck = ifTypeOf({ foo: 1, bar: "bye" }).narrowlyExtends(hybrid);
-
-    // toughLuck should be TRUE because both bar's are strings
-    // but because we need to preserve run-time literal checking on "foo"
-    // it is doing it on both
-    expect(toughLuck).toBe(false);
-
-    type HybridTests = [
-      // foo is a literal, bar is wide
-      Expect<Equal<typeof hybrid, { foo: 1; bar: string }>>,
-      // and type system correctly evaluates
-      Expect<Equal<typeof toughLuck, true>>
-    ];
-    const ToughLuck: HybridTests = [true, true];
-    expect(ToughLuck).toBe(ToughLuck);
-
-    // in addition to this hybrid issue, i'm not sure there is a good
-    // way to do a narrow type check on a function; we can hit some use
-    // cases by converting to a string but that's incomplete
-    const fn = (_c: number) => "string";
-    const fn2 = (_c: number) => "string";
-    const genericFn: Function = () => "string";
-
-    try {
-      const narrow = ifTypeOf(fn).narrowlyExtends(fn2);
-      const asWellAsGeneric = ifTypeOf(fn).narrowlyExtends(genericFn);
-      // the type checks shows that the type system is fine
-      type Functions = [
-        Expect<Equal<typeof narrow, true>>,
-        Expect<Equal<typeof asWellAsGeneric, true>>
-      ];
-      const functions: Functions = [true, true];
-      expect(functions).toBe(functions);
-      throw new Error("The attempt to run narrowlyExtends on a function should throw an error");
-    } 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,22 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect } from "@type-challenges/utils";
-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;
-    type Foo = KeyValue<O, "foo">;
-    type Bar = KeyValue<O, "bar">;
-    type Baz = KeyValue<O, "baz">;
-
-    type cases = [
-      Expect<Equal<Foo, ["foo", 1]>>,
-      Expect<Equal<Bar, ["bar", "hi"]>>,
-      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,35 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect, ExpectFalse } from "@type-challenges/utils";
-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 }>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("explicit assignment does enforce exhaustion of all keys", () => {
-    const origin = { id: "abc", favorite: false };
-    const partial = { id: "abc" };
-    type O = typeof origin;
-    type P = typeof partial;
-
-    type cases = [
-      // not surprisingly appling utility to both
-      // 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:
-      // `const p: SameKeys<O> = { id: "abc" }`
-      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,169 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect, NotEqual } from "@type-challenges/utils";
-import { dictToKv, kvToDict } from "src/runtime/dictionary";
-import { DictFromKv } from "src/types/kv";
-import { keys } from "src/runtime";
-
-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);
-
-    expect(Array.isArray(val)).toBeTruthy();
-    expect(val).toHaveLength(2);
-    expect(val.every((i) => Object.keys(i).includes("key"))).toBeTruthy();
-    expect(val.every((i) => Object.keys(i).includes("value"))).toBeTruthy();
-
-    for (const kv of val) {
-      if (kv.key === "id") {
-        type cases = [Expect<Equal<typeof kv.key, "id">>, Expect<Equal<typeof kv.value, 123>>];
-        const c: cases = [true, true];
-        expect(c).toBe(c);
-      }
-    }
-
-    // TODO: this actually passes some of the time in CLI test and almost always in vs-code
-
-    // type cases = [
-    //   Expect<
-    //     Equal<
-    //       Val,
-    //       [
-    //         {
-    //           key: "id";
-    //           value: 123;
-    //         },
-    //         {
-    //           key: "foo";
-    //           value: "bar";
-    //         }
-    //       ]
-    //     >
-    //   >
-    // ];
-
-    // const c: cases = [true];
-    // expect(c).toBe(c);
-  });
-});
-
-it("basic structure is correct when using array structure", () => {
-  const obj = { id: 123, foo: "bar" } as const;
-  const val = dictToKv(obj);
-
-  expect(Array.isArray(val)).toBeTruthy();
-  expect(val).toHaveLength(2);
-  expect(val.every((i) => Object.keys(i).includes("key"))).toBeTruthy();
-  expect(val.every((i) => Object.keys(i).includes("value"))).toBeTruthy();
-
-  for (const kv of val) {
-    if (kv.key === "id") {
-      type cases = [Expect<Equal<typeof kv.key, "id">>, Expect<Equal<typeof kv.value, 123>>];
-      const c: cases = [true, true];
-      expect(c).toBe(c);
-    }
-  }
-
-  // types are a bit ugly so skipping check when not Tuple type
-});
-
-describe("kvToDict()", () => {
-  it("the DictFromKv<T> utility returns original object type", () => {
-    const val = dictToKv({ id: 123, foo: "bar" });
-    type Back = DictFromKv<typeof val>;
-
-    type cases = [Expect<Equal<Back, { id: 123; foo: "bar" }>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("originating KeyValue array converts to strongly typed dictionary", () => {
-    const obj = kvToDict([
-      { key: "id", value: "abcd" },
-      { key: "color", value: "red" },
-      { key: "favorite", value: true as boolean },
-    ]);
-    type Obj = typeof obj;
-    type Keys = keyof Obj;
-
-    expect(obj.id).toBe("abcd");
-    expect(obj.color).toBe("red");
-    expect(obj.favorite).toBe(true);
-    expect(Object.keys(obj)).toHaveLength(3);
-
-    type cases = [
-      // Keys are known explicitly
-      Expect<Equal<Keys, "id" | "color" | "favorite">>,
-      // Values are literal values where available
-      Expect<Equal<Obj["id"], "abcd">>,
-      Expect<Equal<Obj["color"], "red">>,
-      // if source is wide, then resolution is wide
-      Expect<Equal<Obj["favorite"], boolean>>
-    ];
-
-    const c: cases = [true, true, true, true];
-    expect(c).toBe(c);
-  });
-});
-
-describe("kvToDict / dictToKv inverse", () => {
-  it("run-time inverts correctly (starting with obj)", () => {
-    const obj = { id: 123, foo: "bar" } as const;
-    const inverse = kvToDict(dictToKv(obj));
-
-    expect(keys(inverse).every((i) => inverse[i] === obj[i]));
-  });
-  it("run-time inverts correctly (starting with array)", () => {
-    const arr = [
-      { key: "id", value: 123 },
-      { key: "foo", value: "bar" },
-    ] as const;
-    const inverse = dictToKv(kvToDict(arr));
-
-    expect(inverse).toEqual(arr);
-  });
-
-  it("typing inverts correctly (starting with obj)", () => {
-    const obj = { id: 123, foo: "bar" } as const;
-    const inverse = kvToDict(dictToKv(obj));
-    type Obj = typeof obj;
-    type Inverse = typeof inverse;
-
-    type cases = [
-      // while not precisely equal (due to readonly)
-      Expect<NotEqual<Inverse, Obj>>,
-      // they are equal in each key/value pair
-      Expect<Equal<Inverse["id"], Obj["id"]>>,
-      Expect<Equal<Inverse["foo"], Obj["foo"]>>
-    ];
-    const c: cases = [true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("typing inverts correctly (starting with arr)", () => {
-    const arr = [
-      { key: "id", value: 123 },
-      { key: "foo", value: "bar" },
-    ] as const;
-    const inverse = dictToKv(
-      kvToDict([
-        { key: "id", value: 123 },
-        { key: "foo", value: "bar" },
-      ])
-    );
-    type Arr = typeof arr;
-    type Inverse = typeof inverse[0];
-
-    if (inverse[0].key === "id") {
-      type cases = [
-        // while not precisely equal (due to readonly)
-        Expect<NotEqual<Inverse, Arr>>
-        // they are equal in each key/value pair
-        // Expect<ExpectExtends<Arr, Inverse>>
-      ];
-      const c: cases = [true];
-      expect(c).toBe(c);
-    }
-  });
-});