inferred-types 0.26.0 → 0.28.0

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/createFnWithProps.spec.ts

@@ -5,6 +5,7 @@ describe("createFnWithProps()", () => {
   it("simple fn and prop are combined, type is retained", () => {
     const fn = () => "hi";
     const props = { foo: "bar" };
+    /** combo */
     const combo = createFnWithProps(fn, props);
 
     expect(combo.foo).toBe("bar");

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 { 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"] };
@@ -10,115 +21,337 @@ const i2: I = { title: "i2", color: "green", products: ["foo", "bar", "baz"] };
 
 type O = { title: string; count: number; unnecessary?: number };
 
-describe("MapTo<T> type util", () => {
-  it("1:1 conversion", () => {
-    const m: MapTo<I, O> = (i) => [
-      {
-        title: i.title,
-        count: i.products.length,
-      },
+describe("MapTo<I,O> and MapToFn<I,O>", () => {
+  it("MapTo with 0:M, 0:M cardinality", () => {
+    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, T>>, Expect<Equal<WFn, WT>>];
+    const cases: cases = [true, true];
+  });
+
+  it("MapTo<X> with I -> O[] variable config", () => {
+    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[]];
+    type T2 = (source?: I) => O[];
+    type T3 = (source?: I) => [O, ...O[]];
+
+    type cases = [
+      Expect<Equal<Fn0, T0>>, //
+      Expect<Equal<Fn1, T1>>, //
+      Expect<Equal<Fn2, T2>>, //
+      Expect<Equal<Fn3, T3>> //
+    ];
+    const cases: cases = [true, true, true, true];
+  });
+
+  it("MapTo<X> with I[] -> O variable config", () => {
+    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;
+    type T2 = (source?: I[]) => O | null;
+    type T3 = (source?: I[]) => O;
+
+    type cases = [
+      Expect<Equal<Fn0, T0>>, //
+      Expect<Equal<Fn1, T1>>, //
+      Expect<Equal<Fn2, T2>>, //
+      Expect<Equal<Fn3, T3>> //
+    ];
+    const cases: cases = [true, true, true, true];
+  });
+
+  it("MapFn<X> with I -> O[] variable config", () => {
+    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[];
+    type T2 = <S extends I | I[] | undefined>(source?: S) => S extends I[] ? O[] : O[] | null;
+    type T3 = <S extends I | I[] | undefined>(source?: S) => S extends I[] ? [O, ...O[]] : O[];
+
+    type cases = [
+      Expect<Equal<Fn0, T0>>, //
+      Expect<Equal<Fn1, T1>>, //
+      Expect<Equal<Fn2, T2>>, //
+      Expect<Equal<Fn3, T3>> //
     ];
-    type M = typeof m;
-    type cases = [Expect<Equal<M, MapTo<I, O>>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
+    const cases: cases = [true, true, true, true];
   });
 
-  it("1:1 conversion with non-required", () => {
-    const m: MapTo<I, O> = (i) => [
-      {
-        title: i.title,
-        count: i.products.length,
-        unnecessary: 42,
-      },
+  it("MapFn<X> with I[] -> O variable config", () => {
+    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;
+    type T2 = <S extends I[] | I[][] | undefined>(source?: S) => S extends I[][] ? O[] : O | null;
+    type T3 = <S extends I[] | I[][] | undefined>(source?: S) => S extends I[][] ? [O, ...O[]] : O;
+
+    type cases = [
+      Expect<Equal<Fn0, T0>>, //
+      Expect<Equal<Fn1, T1>>, //
+      Expect<Equal<Fn2, T2>>, //
+      Expect<Equal<Fn3, T3>> //
     ];
-    type M = typeof m;
-    type cases = [Expect<Equal<M, MapTo<I, O>>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
+    const cases: cases = [true, true, true, true];
   });
 
-  it("1:M conversion", () => {
-    const m: MapTo<I, O> = (i) => [
-      {
-        title: i.title,
-        count: i.products.length,
-        unnecessary: 1,
-      },
-      {
-        title: i.title,
-        count: i.products.length + 1,
-        unnecessary: 2,
-      },
+  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>;
+
+    // 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 = [
+      // 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
+        >
+      >
     ];
-    type M = typeof m;
-    type cases = [Expect<Equal<M, MapTo<I, O>>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
+
+    const cases: cases = [true, true, true, true, true, true, true, true, true];
   });
 
-  it("filter input as 1:0 cardinality", () => {
-    const m: MapTo<I, O> = (_i) => [];
-    type M = typeof m;
-    type cases = [Expect<Equal<M, MapTo<I, O>>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
+  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("test 1:1 mapping", () => {
-    const m = mapTo<I, O>((i) => [
-      {
-        title: i.title,
-        count: i.products.length,
-      },
-    ]);
-    type M = typeof m;
-    type R = ReturnType<M>;
-
-    // runtime
-    expect(m(i)).toEqual([{ title: i.title, count: i.products.length }]);
-    // types
-    type cases = [Expect<Equal<R, O[]>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
+  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({
+        cardinality: "I[] -> O",
+        output: "req",
+      })
+      .map<I, O>((i) => ({
+        title: "count of products",
+        count: i.reduce((acc, i) => (acc = acc + i.products.length), 0),
+      }));
+
+    const summary = m([i, i2]);
+    expect(summary.title).toBe("count of products");
+    expect(summary.count).toBe(6);
+  });
+
+  it("1:1 conversion", () => {
+    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(3);
+  });
+
+  it("1:1 with 1:M conversion setting", () => {
+    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);
+    expect(o[0]?.title).toBe(i.title);
+    expect(o[0]?.count).toBe(3);
   });
 
-  it("test 1:1 mapping with extraneous prop", () => {
-    const m = mapTo<I, O>((i) => [
-      {
-        title: i.title,
-        count: i.products.length,
-        extraneous: 42,
-      },
-    ]);
-    type M = typeof m;
-    type R = ReturnType<M>;
-
-    // runtime
-    // TODO: extraneous props are cut out of the type but still allows us to return `O` values with extraneous props!
-    // expect(m(i)).toEqual([{ title: i.title, count: i.products.length }]);
-    // types
-    type cases = [Expect<Equal<R, O[]>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
+  it("1:M conversion ", () => {
+    const m = mapTo
+      .config({ output: "req", cardinality: "I -> O[]" })
+      .map<I, O>((i) => [{ title: i.title, count: i.products.length }]);
+    const o = m([i, i2]);
+
+    expect(o.length).toBe(2);
+    o.map((item) => expect("title" in item).toBeTruthy());
   });
 
-  it("test input filtering", () => {
-    const m = mapTo<I, O>((x) => {
-      return x.title === "i2"
-        ? null
-        : [
-            {
-              title: i.title,
-              count: i.products.length,
-            },
-          ];
+  it("M:1 conversion", () => {
+    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),
+      };
     });
-    const results = m([i, i2]);
+    const o = m([i, i2]);
+
+    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(results).toHaveLength(1);
-    expect(results[0].title).toBe("Test");
+    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";