inferred-types 0.37.0 → 0.37.2

package/tests/dictionary/DictChangeValue.test.ts

@@ -1,30 +0,0 @@
-import { describe, it } from "vitest";
-import type { Expect, Equal } from "@type-challenges/utils";
-import { DictChangeValue } from "../../src/types/dictionary/DictChangeValue";
-import { SimplifyObject } from "../../src/types/SimplifyObject";
-
-const test_obj = {
-  foo: "hello world",
-  bar: 42,
-  baz: () => "that's all folks",
-} as const;
-type TestObj = typeof test_obj;
-
-describe("DictChangeValue", () => {
-  it("convert all KVs to a single value type", () => {
-    type T = DictChangeValue<TestObj, number>;
-
-    type cases = [Expect<Equal<T, { foo: number; bar: number; baz: number }>>];
-    const cases: cases = [true];
-  });
-
-  it("convert functions values to boolean", () => {
-    type F = DictChangeValue<TestObj, boolean, Function>;
-    type S = DictChangeValue<TestObj, string, string>;
-    type N = DictChangeValue<TestObj, number, number>;
-    type T = SimplifyObject<F & S & N>;
-
-    type cases = [Expect<Equal<T, { foo: string; bar: number; baz: boolean }>>];
-    const cases: cases = [true];
-  });
-});

package/tests/dictionary/DictPartialApplication.test.ts

@@ -1,43 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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,28 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect } from "@type-challenges/utils";
-import { Get } from "src/types";
-import { defineType } from "src/runtime";
-
-describe("Get<T, K> type utility", () => {
-  it("Get<T,K> works with literals and wide types", () => {
-    const input = defineType({ id: 1234 })({ foo: 1, bar: "hi" });
-    type Input = typeof input;
-
-    type Id = Get<Input, "id">;
-    type Foo = Get<Input, "foo">;
-    type Bar = Get<Input, "bar">;
-    type Nada = Get<Input, "nada">;
-
-    type cases = [
-      // valid props are pulled off
-      Expect<Equal<Id, 1234>>,
-      Expect<Equal<Foo, number>>,
-      Expect<Equal<Bar, string>>,
-      // non-existent props return never
-      Expect<Equal<Nada, never>>
-    ];
-    const c: cases = [true, true, true, true];
-    expect(c).toBe(c);
-  });
-});

package/tests/dictionary/IntersectingKeys.test.ts

@@ -1,42 +0,0 @@
-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/MutableProps.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from "vitest";
-import type { Expect, Equal } from "@type-challenges/utils";
-
-import { MutableProps } from "src/types/dictionary";
-
-describe("MutableProps<T,M>", () => {
-  it("works as expected", () => {
-    type Test = { foo: string; bar?: number; baz: Readonly<boolean> };
-    type Foo = MutableProps<Test, "foo" | "bar">;
-    type Bar = MutableProps<Test, "bar">;
-    type FooBar = MutableProps<Test, "foo" | "bar">;
-    type FooBaz = MutableProps<Test, "foo" | "baz">;
-
-    type cases = [
-      Expect<Equal<Foo, { foo: string; bar?: Readonly<number>; readonly baz: Readonly<boolean> }>>,
-      Expect<
-        Equal<
-          Bar,
-          { readonly foo: Readonly<string>; bar?: number; readonly baz: Readonly<boolean> }
-        >
-      >,
-      Expect<Equal<FooBar, { foo: string; bar?: number; readonly baz: Readonly<boolean> }>>,
-      Expect<
-        Equal<FooBaz, { foo: string; readonly bar?: Readonly<number>; baz: Readonly<boolean> }>
-      >
-    ];
-    const cases: cases = [true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-});

package/tests/dictionary/OptionalKeys.test.ts

@@ -1,24 +0,0 @@
-import { describe, it, expect } from "vitest";
-import type { Expect, Equal } from "@type-challenges/utils";
-import { OptionalKeys } from "src/types/dictionary";
-
-type Test = { title: string; value: number; color?: string };
-
-describe("OptionalKeys<T, V>", () => {
-  it("basic usage without filtering on value", () => {
-    type T = OptionalKeys<Test>;
-
-    type cases = [Expect<Equal<T, "color">>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-
-  it("basic usage with a value filter", () => {
-    type T1 = OptionalKeys<Test, string>;
-    type T2 = OptionalKeys<Test, number>;
-
-    type cases = [Expect<Equal<T1, "color">>, Expect<Equal<T2, never>>];
-    const cases: cases = [true, true];
-    expect(cases).toBe(cases);
-  });
-});

package/tests/dictionary/PrependValuesWithFunction.test.ts

@@ -1,34 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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/dictionary/RequiredKeys.test.ts

@@ -1,53 +0,0 @@
-import { describe, it, expect } from "vitest";
-import type { Expect, Equal } from "@type-challenges/utils";
-import { RequiredKeys } from "src/types/dictionary";
-import { First, Narrowable } from "src";
-
-type Test = { title: string; value: number; color?: string };
-
-describe("RequiredKeys<T, V>", () => {
-  it("basic usage without filtering on value", () => {
-    type T = RequiredKeys<Test>;
-
-    type cases = [Expect<Equal<T, "title" | "value">>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-
-  it("basic usage with a value filter", () => {
-    type T1 = RequiredKeys<Test, string>;
-    type T2 = RequiredKeys<Test, number>;
-
-    type cases = [Expect<Equal<T1, "title">>, Expect<Equal<T2, "value">>];
-    const cases: cases = [true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("typed explicitly", () => {
-    type O = {
-      id: number;
-      name: string;
-      title: string;
-      cost?: number;
-      color?: string;
-    };
-
-    const genericArr: O[] = [
-      { id: 1, name: "foo", title: "one", cost: 15 },
-      { id: 2, name: "bar", title: "one" },
-      { id: 3, name: "baz", title: "two", cost: 45, color: "green" },
-    ];
-    const fn = <T extends Record<string, Narrowable>, A extends readonly T[]>(arr: A): A => arr;
-
-    const v = fn(genericArr);
-    type V = typeof v;
-    type T1 = RequiredKeys<First<V>>;
-    type T2 = RequiredKeys<First<V>, string>;
-
-    type cases = [
-      Expect<Equal<T1, "id" | "name" | "title">>, //
-      Expect<Equal<T2, "name" | "title">>
-    ];
-    const cases: cases = [true, true];
-  });
-});

package/tests/dictionary/TypeDefault.test.ts

@@ -1,76 +0,0 @@
-import { describe, it } from "vitest";
-import { Equal, Expect } from "@type-challenges/utils";
-import { TypeDefault } from "src/types/boolean-logic/TypeDefault";
-import { literal } from "src/runtime/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];
-  });
-});