inferred-types 0.27.0 → 0.28.2

package/src/utility/dictionary/merge.ts

@@ -0,0 +1,36 @@
+import { Mutable, Narrowable, SimplifyObject, TypeDefault } from "src/types";
+import { keys } from "../keys";
+import { isObject } from "../runtime";
+
+/**
+ * **merge**(val, defaultVal)
+ *
+ * Merges two values together where the second property is considered the
+ * the "default value". This means that in any cases where the primary value
+ * os _undefined_ it will be replaced by the default value. The merging will
+ * also recurse into object types to do matching at a property-by-property
+ * level.
+ *
+ * As much as is possible, this utility will maintain strong and narrow types
+ * across the merge process.
+ */
+export const merge = <T extends Narrowable, D extends Narrowable>(
+  val: T,
+  defVal: D
+): SimplifyObject<Mutable<TypeDefault<T, D>>> => {
+  const result =
+    val === undefined
+      ? // value is undefined; use default value
+        defVal
+      : isObject(defVal) && isObject(val)
+      ? // value and and default value are objects; recurse via default values
+        keys(defVal as Record<string, any>).reduce((acc, key) => {
+          const v = (val as Record<string, any>)[key];
+          const dv = (defVal as Record<string, any>)[key];
+
+          return { ...acc, [key]: merge(v, dv) };
+        }, {} as Record<string, any>)
+      : val;
+
+  return result as SimplifyObject<Mutable<TypeDefault<T, D>>>;
+};

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

@@ -1,19 +1,5 @@
-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
-    T extends FunctionType
-    ? // when a function with props is found, categorize as a function not object
-      false
-    : Mutable<T> extends any[]
-    ? // Array's are objects too but in our narrower definition we're looking only
-      // dictionary based arrays.
-      false
-    : true
-  : false;
+import { FunctionType, Narrowable, Not } from "src/types";
+import { IsObject } from "src/types/TypeInfo";
 
 export type ObjectType = Not<Record<string, Narrowable>, FunctionType>;
 

package/tests/TypeInfo/IsLiteral.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { Equal, Expect } from "@type-challenges/utils";
-import { IsBooleanLiteral, IsLiteral } from "src/types";
+import { IsBooleanLiteral, IsLiteral, IsOptionalLiteral } from "src/types";
 
 describe("IsLiteral<T> type utility", () => {
   it("string values", () => {
@@ -46,4 +46,20 @@ describe("IsLiteral<T> type utility", () => {
     expect(typeof v).toBe("boolean");
     expect(typeof vl).toBe("boolean");
   });
+
+  it("union with undefined", () => {
+    const vb = true as true | undefined;
+    const vs = "foo" as "foo" | undefined;
+    const vn = 42 as 42 | undefined;
+
+    type cases = [
+      Expect<Equal<IsLiteral<Exclude<typeof vb, undefined>>, true>>, //
+      Expect<Equal<IsLiteral<Exclude<typeof vs, undefined>>, true>>, //
+      Expect<Equal<IsLiteral<Exclude<typeof vn, undefined>>, true>>, //
+      Expect<Equal<IsOptionalLiteral<typeof vb>, true>>, //
+      Expect<Equal<IsOptionalLiteral<typeof vs>, true>>, //
+      Expect<Equal<IsOptionalLiteral<typeof vn>, true>> //
+    ];
+    const cases: cases = [true, true, true, true, true, true];
+  });
 });

package/tests/dictionary/IntersectingKeys.test.ts

@@ -0,0 +1,42 @@
+import { describe, it } from "vitest";
+
+import type { Expect, Equal } from "@type-challenges/utils";
+import { IntersectingKeys } from "src/types/dictionary";
+
+describe("IntersectingKeys<T,U>", () => {
+  it("with overlap", () => {
+    type T = { foo: string; bar: number; baz: any };
+    type U = { foo: string; bar: number };
+    type V = IntersectingKeys<T, U>;
+
+    type cases = [Expect<Equal<V, "foo" | "bar">>];
+    const cases: cases = [true];
+  });
+
+  it("no overlap", () => {
+    type T = { foo1: string; bar1: number; baz1: any };
+    type U = { foo: string; bar: number };
+    type V = IntersectingKeys<T, U>;
+    type VU = Exclude<U, V>;
+
+    type cases = [
+      // intersection is "never"
+      Expect<Equal<VU, U>>,
+      // Excluding "never" results in no change
+      Expect<Equal<VU, U>>
+    ];
+    const cases: cases = [true, true];
+  });
+
+  it("using string[] instead of object", () => {
+    type T = { foo: string; bar: number; baz: any };
+    type U = readonly ["foo", "bart"];
+    type V = IntersectingKeys<T, U>;
+
+    type cases = [
+      //
+      Expect<Equal<V, "foo">>
+    ];
+    const cases: cases = [true];
+  });
+});

package/tests/dictionary/TypeDefault.test.ts

@@ -0,0 +1,76 @@
+import { describe, it } from "vitest";
+import { Equal, Expect } from "@type-challenges/utils";
+import { TypeDefault } from "src/types/TypeInfo/TypeDefault";
+import { literal } from "src/utility/literals";
+
+describe("TypeDefault<T,D>", () => {
+  it("T/D as dictionary", () => {
+    type T = { foo?: "foo" | "fooy" | undefined; bar?: 42 | 53 | undefined };
+    type D = { foo: "foo"; bar: 42 };
+    type V = TypeDefault<T, D>;
+    const t1 = literal({ foo: undefined, bar: 56 });
+    type V1 = TypeDefault<typeof t1, D>;
+    const t2 = { foo: undefined, bar: 56 };
+    type V2 = TypeDefault<typeof t2, D>;
+    // const t3 = { bar: 56, baz: "hello" } as const;
+    // type _V3 = TypeDefault<typeof t3, D>;
+
+    type cases = [
+      // D's props all extend T
+      Expect<Equal<V, D>>,
+      // foo is inherited from default, bar keeps literal type from T
+      Expect<Equal<V1, { foo: "foo"; bar: 56 }>>,
+      // bar is widened to "number" because that's the resolution T had
+      Expect<Equal<V2, { foo: "foo"; bar: number }>>
+      // the T prop has the prop "baz" which did not exist on D
+      // TODO: this last test SHOULD work but doesn't yet
+      // Expect<Equal<V3, { foo: "foo"; bar: 56; baz: "hello" }>>
+    ];
+    const cases: cases = [true, true, true];
+  });
+  it("T is undefined, D is a dictionary", () => {
+    type T = undefined;
+    type D = { foo: "foo"; bar: 42 };
+    type V = TypeDefault<T, D>;
+
+    type cases = [
+      // the value's type is converted to the default
+      Expect<Equal<V, D>>
+    ];
+    const cases: cases = [true];
+  });
+
+  it("T and D are scalars", () => {
+    type T1 = 5;
+    type D1 = 8;
+    type V1 = TypeDefault<T1, D1>;
+
+    type T2 = "foo";
+    type D2 = "bar";
+    type V2 = TypeDefault<T2, D2>;
+
+    type T3 = undefined;
+    type D3 = "bar";
+    type V3 = TypeDefault<T3, D3>;
+
+    type cases = [
+      Expect<Equal<V1, 5>>, //
+      Expect<Equal<V2, "foo">>,
+      Expect<Equal<V3, "bar">>
+    ];
+
+    const cases: cases = [true, true, true];
+  });
+
+  it("Property includes a function", () => {
+    type T1 = { foo: "foo"; bar: undefined };
+    type D1 = { foo: "bar"; bar: () => "hello" };
+    type V1 = TypeDefault<T1, D1>;
+
+    type cases = [
+      Expect<Equal<V1["foo"], "foo">>, //
+      Expect<Equal<V1["bar"], () => "hello">>
+    ];
+    const cases: cases = [true, true];
+  });
+});

package/tests/dictionary/mapTo.test.ts

@@ -1,8 +1,19 @@
-import { MapDirection, MapFn, MapTo } from "src/types/dictionary";
+import {
+  FinalizedMapConfig,
+  MapCardinality,
+  MapFn,
+  MapTo,
+  AsFinalizedConfig,
+  MapConfig,
+  ConfiguredMap,
+} from "src/types/dictionary";
 import { describe, expect, it } from "vitest";
-
 import type { Expect, Equal } from "@type-challenges/utils";
-import { mapTo } from "src/utility/dictionary/mapTo";
+import {
+  DEFAULT_MANY_TO_ONE_MAPPING,
+  DEFAULT_ONE_TO_MANY_MAPPING,
+  mapTo,
+} from "src/utility/dictionary/mapTo";
 
 type I = { title: string; color: string; products: string[] };
 const i: I = { title: "Test", color: "green", products: ["foo", "bar", "baz"] };
@@ -12,30 +23,29 @@ type O = { title: string; count: number; unnecessary?: number };
 
 describe("MapTo<I,O> and MapToFn<I,O>", () => {
   it("MapTo with 0:M, 0:M cardinality", () => {
-    type Fn = MapTo<I, O>;
-    type Fn2 = MapTo<I, O, "req", MapDirection.OneToMany, "opt">;
-    type WFn = MapFn<I, O>;
-    type WFn2 = MapFn<I, O, "req", MapDirection.OneToMany, "opt">;
+    type C = FinalizedMapConfig<"req", "I -> O[]", "opt">;
+    type Fn = MapTo<I, O, C>;
+    type WFn = MapFn<I, O, C>;
 
     /** userland mapping function */
     type T = (source: I) => O[];
     /** exposed via mapTo() util */
     type WT = <S extends I | I[]>(source: S) => S extends I[] ? O[] : O[] | null;
 
-    type cases = [
-      Expect<Equal<Fn, Fn2>>, // implicit default = explicit values
-      Expect<Equal<WFn, WFn2>>, // implicit default = explicit values
-      Expect<Equal<Fn, T>>,
-      Expect<Equal<WFn, WT>>
-    ];
-    const cases: cases = [true, true, true, true];
+    type cases = [Expect<Equal<Fn, T>>, Expect<Equal<WFn, WT>>];
+    const cases: cases = [true, true];
   });
 
   it("MapTo<X> with I -> O[] variable config", () => {
-    type Fn0 = MapTo<I, O, "req", MapDirection.OneToMany, "opt">;
-    type Fn1 = MapTo<I, O, "req", MapDirection.OneToMany, "req">;
-    type Fn2 = MapTo<I, O, "opt", MapDirection.OneToMany, "opt">;
-    type Fn3 = MapTo<I, O, "opt", "I -> O[]", "req">;
+    type C0 = FinalizedMapConfig<"req", "I -> O[]", "opt">;
+    type C1 = FinalizedMapConfig<"req", "I -> O[]", "req">;
+    type C2 = FinalizedMapConfig<"opt", "I -> O[]", "opt">;
+    type C3 = FinalizedMapConfig<"opt", "I -> O[]", "req">;
+
+    type Fn0 = MapTo<I, O, C0>;
+    type Fn1 = MapTo<I, O, C1>;
+    type Fn2 = MapTo<I, O, C2>;
+    type Fn3 = MapTo<I, O, C3>;
 
     type T0 = (source: I) => O[];
     type T1 = (source: I) => [O, ...O[]];
@@ -52,10 +62,15 @@ describe("MapTo<I,O> and MapToFn<I,O>", () => {
   });
 
   it("MapTo<X> with I[] -> O variable config", () => {
-    type Fn0 = MapTo<I, O, "req", "I[] -> O", "opt">;
-    type Fn1 = MapTo<I, O, "req", "I[] -> O", "req">;
-    type Fn2 = MapTo<I, O, "opt", "I[] -> O", "opt">;
-    type Fn3 = MapTo<I, O, "opt", "I[] -> O", "req">;
+    type C0 = FinalizedMapConfig<"req", "I[] -> O", "opt">;
+    type C1 = FinalizedMapConfig<"req", "I[] -> O", "req">;
+    type C2 = FinalizedMapConfig<"opt", "I[] -> O", "opt">;
+    type C3 = FinalizedMapConfig<"opt", "I[] -> O", "req">;
+
+    type Fn0 = MapTo<I, O, C0>;
+    type Fn1 = MapTo<I, O, C1>;
+    type Fn2 = MapTo<I, O, C2>;
+    type Fn3 = MapTo<I, O, C3>;
 
     type T0 = (source: I[]) => O | null;
     type T1 = (source: I[]) => O;
@@ -72,10 +87,15 @@ describe("MapTo<I,O> and MapToFn<I,O>", () => {
   });
 
   it("MapFn<X> with I -> O[] variable config", () => {
-    type Fn0 = MapFn<I, O, "req", "I -> O[]", "opt">;
-    type Fn1 = MapFn<I, O, "req", "I -> O[]", "req">;
-    type Fn2 = MapFn<I, O, "opt", "I -> O[]", "opt">;
-    type Fn3 = MapFn<I, O, "opt", "I -> O[]", "req">;
+    type C0 = FinalizedMapConfig<"req", "I -> O[]", "opt">;
+    type C1 = FinalizedMapConfig<"req", "I -> O[]", "req">;
+    type C2 = FinalizedMapConfig<"opt", "I -> O[]", "opt">;
+    type C3 = FinalizedMapConfig<"opt", "I -> O[]", "req">;
+
+    type Fn0 = MapFn<I, O, C0>;
+    type Fn1 = MapFn<I, O, C1>;
+    type Fn2 = MapFn<I, O, C2>;
+    type Fn3 = MapFn<I, O, C3>;
 
     type T0 = <S extends I | I[]>(source: S) => S extends I[] ? O[] : O[] | null;
     type T1 = <S extends I | I[]>(source: S) => S extends I[] ? [O, ...O[]] : O[];
@@ -92,10 +112,15 @@ describe("MapTo<I,O> and MapToFn<I,O>", () => {
   });
 
   it("MapFn<X> with I[] -> O variable config", () => {
-    type Fn0 = MapFn<I, O, "req", "I[] -> O", "opt">;
-    type Fn1 = MapFn<I, O, "req", "I[] -> O", "req">;
-    type Fn2 = MapFn<I, O, "opt", "I[] -> O", "opt">;
-    type Fn3 = MapFn<I, O, "opt", "I[] -> O", "req">;
+    type C0 = FinalizedMapConfig<"req", "I[] -> O", "opt">;
+    type C1 = FinalizedMapConfig<"req", "I[] -> O", "req">;
+    type C2 = FinalizedMapConfig<"opt", "I[] -> O", "opt">;
+    type C3 = FinalizedMapConfig<"opt", "I[] -> O", "req">;
+
+    type Fn0 = MapFn<I, O, C0>;
+    type Fn1 = MapFn<I, O, C1>;
+    type Fn2 = MapFn<I, O, C2>;
+    type Fn3 = MapFn<I, O, C3>;
 
     type T0 = <S extends I[] | I[][]>(source: S) => S extends I[][] ? O[] : O | null;
     type T1 = <S extends I[] | I[][]>(source: S) => S extends I[][] ? [O, ...O[]] : O;
@@ -111,28 +136,143 @@ describe("MapTo<I,O> and MapToFn<I,O>", () => {
     const cases: cases = [true, true, true, true];
   });
 
-  it("walk through of mapTo types", () => {
-    const t1 = mapTo<I, O>((i) => [{ title: i.title, count: i.products.length }]);
-    type T1 = typeof t1;
+  it("ToConfiguredMap<U,D> type utility", () => {
+    // userland overrides cardinality
+    type U1 = MapConfig<undefined, "I -> O", undefined>;
+    type D1 = typeof DEFAULT_ONE_TO_MANY_MAPPING;
+    type CD1 = AsFinalizedConfig<U1, D1>;
+    type CM1 = ConfiguredMap<CD1>;
+    type M1 = CM1["map"];
+    type M1P = Parameters<M1>;
+    type M1R = ReturnType<M1>;
 
-    const a1 = mapTo
-      .config({ input: "req" })
-      .map<I, O>((i) => [{ title: i.title, count: i.products.length }]);
-    type A1 = typeof a1;
+    // userland provides nothing; leaves default value
+    type U2 = MapConfig<undefined, undefined, undefined>;
+    type D2 = typeof DEFAULT_MANY_TO_ONE_MAPPING;
+    type C2 = AsFinalizedConfig<U2, D2>;
+    type CM2 = ConfiguredMap<C2>;
+    type M2 = CM2["map"];
+    type M2P = Parameters<M2>;
+    type M2R = ReturnType<M2>;
+
+    type U3 = MapConfig<undefined, undefined, "opt">;
+    type D3 = typeof DEFAULT_MANY_TO_ONE_MAPPING;
+    type C3 = AsFinalizedConfig<U3, D3>;
+    type CM3 = ConfiguredMap<C3>;
+    type M3 = CM3["map"];
+    type M3P = Parameters<M3>;
+    type M3R = ReturnType<M3>;
 
     type cases = [
-      Expect<Equal<T1, MapFn<I, O>>>, //
-      Expect<Equal<T1, A1>>
+      // merged configuration
+      Expect<Equal<CD1, FinalizedMapConfig<"req", "I -> O", "opt">>>,
+      // map() function's parameters (unknown is I)
+      Expect<Equal<[map: (source: unknown) => unknown], M1P>>,
+      // map() function's return value
+      Expect<
+        Equal<<S extends unknown>(source: S) => S extends unknown[] ? unknown[] : unknown, M1R>
+      >,
+
+      // merged configuration is same as default for M:1
+      Expect<Equal<C2, FinalizedMapConfig<"req", "I[] -> O", "req">>>,
+      // map() function's parameters (unknown is I)
+      Expect<Equal<[map: (source: unknown[]) => unknown], M2P>>,
+      // map() function's return value
+      Expect<
+        Equal<
+          <S extends unknown[] | unknown[][]>(
+            source: S
+          ) => S extends unknown[][] ? [unknown, ...unknown[]] : unknown,
+          M2R
+        >
+      >,
+
+      // merged configuration should be M:1 default with an "opt" for output
+      Expect<Equal<C3, FinalizedMapConfig<"req", "I[] -> O", "opt">>>,
+      // map() function's parameters (unknown is I)
+      Expect<Equal<[map: (source: unknown[]) => unknown | null], M3P>>,
+      // map() function's return value
+      Expect<
+        Equal<
+          <S extends unknown[] | unknown[][]>(
+            source: S
+          ) => S extends unknown[][] ? unknown[] : unknown,
+          M3R
+        >
+      >
+    ];
+
+    const cases: cases = [true, true, true, true, true, true, true, true, true];
+  });
+
+  it("config() matches cardinality configs", () => {
+    const a1 = mapTo.oneToMany();
+    const b1 = mapTo.config({
+      input: "req",
+      output: "opt",
+      cardinality: "I -> O[]",
+    });
+
+    expect(a1.input).toBe(b1.input);
+    expect(a1.output).toBe(b1.output);
+    expect(a1.cardinality).toBe(b1.cardinality);
+
+    const a2 = mapTo.oneToOne();
+    const b2 = mapTo.config({
+      input: "req",
+      output: "req",
+      cardinality: "I -> O",
+    });
+
+    expect(a2.input).toBe(b2.input);
+    expect(a2.output).toBe(b2.output);
+    expect(a2.cardinality).toBe(b2.cardinality);
+
+    type cases = [
+      Expect<Equal<typeof a1, typeof a2>>, //
+      Expect<Equal<typeof b1, typeof b2>>
     ];
     const cases: cases = [true, true];
   });
 });
 
 describe("mapTo() utility function", () => {
+  it("Partial application of mapTo utility", () => {
+    const m1 = mapTo.manyToOne();
+
+    expect(m1.input).toBe("req");
+    expect(m1.output).toBe("req");
+    expect(m1.cardinality).toBe(MapCardinality.ManyToOne);
+
+    const m2 = mapTo.manyToOne({ output: "opt" });
+
+    expect(m2.input).toBe("req");
+    expect(m2.output).toBe("opt");
+    expect(m2.cardinality).toBe(MapCardinality.ManyToOne);
+
+    const o1 = mapTo.oneToOne();
+
+    expect(o1.input).toBe("req");
+    expect(o1.output).toBe("req");
+    expect(o1.cardinality).toBe(MapCardinality.OneToOne);
+
+    const o2 = mapTo.oneToOne({ output: "opt" });
+
+    expect(o2.input).toBe("req");
+    expect(o2.output).toBe("opt");
+    expect(o2.cardinality).toBe(MapCardinality.OneToOne);
+
+    const c1 = mapTo.config({ input: "opt" });
+
+    expect(c1.input).toBe("opt");
+    expect(c1.output).toBe("opt");
+    expect(c1.cardinality).toBe(MapCardinality.OneToMany);
+  });
+
   it("M:1 conversion", () => {
     const m = mapTo
       .config({
-        direction: "I[] -> O",
+        cardinality: "I[] -> O",
         output: "req",
       })
       .map<I, O>((i) => ({
@@ -146,9 +286,10 @@ describe("mapTo() utility function", () => {
   });
 
   it("1:1 conversion", () => {
-    const m = mapTo
-      .config({ output: "req", direction: MapDirection.OneToOne })
-      .map<I, O>((i) => ({ title: i.title, count: i.products.length }));
+    const m = mapTo.oneToOne().map<I, O>((i) => ({
+      title: i.title,
+      count: i.products.length,
+    }));
     const o = m(i);
 
     expect(o?.title).toBe(i.title);
@@ -156,9 +297,11 @@ describe("mapTo() utility function", () => {
   });
 
   it("1:1 with 1:M conversion setting", () => {
-    const m = mapTo
-      .config({ output: "req", direction: MapDirection.OneToMany })
-      .map<I, O>((i) => [{ title: i.title, count: i.products.length }]);
+    const mc = mapTo.config({
+      output: "req",
+      cardinality: "I -> O[]",
+    });
+    const m = mc.map<I, O>((i) => [{ title: i.title, count: i.products.length }]);
     const o = m(i);
 
     expect(o.length).toBe(1);
@@ -168,7 +311,7 @@ describe("mapTo() utility function", () => {
 
   it("1:M conversion ", () => {
     const m = mapTo
-      .config({ output: "req", direction: MapDirection.OneToMany })
+      .config({ output: "req", cardinality: "I -> O[]" })
       .map<I, O>((i) => [{ title: i.title, count: i.products.length }]);
     const o = m([i, i2]);
 
@@ -177,7 +320,7 @@ describe("mapTo() utility function", () => {
   });
 
   it("M:1 conversion", () => {
-    const m = mapTo.config({ output: "req", direction: MapDirection.ManyToOne }).map<I, O>((i) => {
+    const m = mapTo.config({ output: "req", cardinality: "I[] -> O" }).map<I, O>((i) => {
       return {
         title: "summary",
         count: i.reduce((acc, i) => (acc = acc + i.products.length), 0),
@@ -188,4 +331,27 @@ describe("mapTo() utility function", () => {
     expect(o.title).toBe("summary");
     expect(o.count).toBe(6);
   });
+
+  it("1:1 conversion using oneToOne() configurator", () => {
+    const m = mapTo.oneToOne().map<I, O>((i) => ({ title: i.title, count: i.products.length }));
+    const o = m(i);
+
+    expect(o.title).toBe(i.title);
+    expect(o.count).toBe(i.products.length);
+  });
+
+  it("M:1 conversion using manyToOne() configurator", () => {
+    const m = mapTo //
+      .manyToOne()
+      .map<I, O>((i) => {
+        return {
+          title: "summary",
+          count: i.reduce((acc, cur) => (acc = acc + cur.products.length), 0),
+        };
+      });
+    const o = m([i, i2]);
+
+    expect(o.title).toBe("summary");
+    expect(o.count).toBe(6);
+  });
 });

package/tests/dictionary/merge.test.ts

@@ -0,0 +1,41 @@
+import { Equal, Expect } from "@type-challenges/utils";
+import { merge } from "src/utility/dictionary/merge";
+import { describe, expect, it } from "vitest";
+
+describe("merge() utility", () => {
+  it("merge to scalars/undefined", () => {
+    const m1 = merge(undefined, 6);
+    const m2 = merge(42, 6);
+
+    expect(m1).toBe(6);
+    expect(m2).toBe(42);
+
+    type cases = [
+      Expect<Equal<typeof m1, 6>>, //
+      Expect<Equal<typeof m2, 42>>
+    ];
+    const cases: cases = [true, true];
+  });
+
+  it("merge two objects", () => {
+    const o1 = merge(
+      { foo: "foo", baz: false, color: { fav: undefined, next: "green" } } as const,
+      { foo: "bar", bar: 42, color: { fav: "red", next: "" as string } } as const
+    );
+    type O1 = typeof o1;
+
+    // runtime
+    expect(o1.foo).toBe("foo");
+    expect(o1.bar).toBe(42);
+    expect(o1.color.fav).toBe("red");
+    expect(o1.color.next).toBe("green");
+
+    // design time
+    type cases = [
+      Expect<Equal<O1["foo"], "foo">>, //
+      Expect<Equal<O1["bar"], 42>>,
+      Expect<Equal<O1["color"], { fav: "red"; next: "green" }>>
+    ];
+    const cases: cases = [true, true, true];
+  });
+});

package/tests/withValue.spec.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect } from "vitest";
 import type { Expect, Equal } from "@type-challenges/utils";
-
 import { createFnWithProps, type, withValue } from "../src/utility";
 import { FunctionType, WithValue } from "../src";