inferred-types 0.36.4 → 0.37.1

package/tests/kv/entries-spec.ts

@@ -1,65 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import type { Expect, NotEqual, Equal, ExpectExtends } from "@type-challenges/utils";
-import { entries } from "src/runtime";
-
-describe("entries() => ", () => {
-  it("literal types are retained", () => {
-    const obj = { foo: 1, bar: "hi" } as const;
-    type Value = 1 | "hi";
-
-    for (const [k, v] of entries(obj)) {
-      type cases = [
-        // the key should extend string
-        Expect<ExpectExtends<string, typeof k>>,
-        // but because it's a literal, it should not be a string
-        Expect<NotEqual<string, typeof k>>,
-        // this is shown as a union of literals here
-        Expect<Equal<"foo" | "bar", typeof k>>,
-        // the value should also be a union of the possible literals
-        Expect<ExpectExtends<typeof v, Value>>
-      ];
-      const cases: cases = [true, true, true, true];
-      expect(cases).toBe(cases);
-
-      if (k === "foo") {
-        type cases2 = [
-          // inside a conditional, typescript knows as an
-          // explicit type and no longer a union of keys
-          Expect<Equal<typeof k, "foo">>,
-          // but the value is still a union of all KV
-          // values which makes it far less valuable
-          Expect<Equal<typeof v, Value>>
-        ];
-        const c: cases2 = [true, true];
-        expect(c).toBe(c);
-      }
-    }
-
-    // for (const entry of entries(obj)) {
-    //   if (entry[0] === "foo") {
-    //     type K = typeof entry[0];
-    //     type V = typeof entry[1];
-
-    //     type cases3 = [
-    //       // inside a conditional, typescript knows as an
-    //       // explicit type and no longer a union of keys
-    //       Expect<Equal<typeof entry[0], "foo">>,
-    //       // but the value is still a union of all KV
-    //       // values which makes it far less valuable
-    //       Expect<Equal<typeof v, Value>>,
-    //     ];
-    //     const c: cases3 = [true, true];
-    //     expect(c).toBe(c);
-    //   }
-    // }
-  });
-
-  it("values maintain their implicit type even when nested objects", () => {
-    const obj = { foo: { bar: { baz: 42 } } };
-    for (const [k, v] of entries(obj)) {
-      expect(k).toBe("foo");
-      expect(v).toBe(obj.foo);
-    }
-  });
-});

package/tests/kv/keys.spec.ts

@@ -1,66 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Keys } from "src/types/Keys";
-import type { Expect, Equal } from "@type-challenges/utils";
-import { defineType, keys } from "src/runtime";
-
-describe("Keys<T>", () => {
-  it("Keys<T> is shorthand for keyof T", () => {
-    const obj = { foo: 1, bar: 3 };
-    type O = keyof typeof obj;
-    type keys = Keys<typeof obj>;
-
-    type cases = [Expect<Equal<O, keys>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-
-  it("Keys<T> can also convert an array of strings into a union type", () => {
-    const arr = ["foo", "bar"] as const;
-    type Arr = typeof arr;
-    type MyKeys = Keys<Arr>;
-
-    type cases = [Expect<Equal<MyKeys, "foo" | "bar">>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-
-  it("Keys<T,W> can exclude certain keys", () => {
-    const obj = { foo: 1, bar: 3 };
-    const arr = ["foo", "bar"] as const;
-    type OKeys = Keys<typeof obj, "foo">;
-    type OArr = Keys<typeof arr, "foo">;
-
-    type cases = [Expect<Equal<OKeys, "bar">>, Expect<Equal<OArr, "bar">>];
-    const cases: cases = [true, true];
-    expect(cases).toBe(cases);
-  });
-});
-
-describe("keys() utility", () => {
-  it("with just object passed in, keys are extracted as expected", () => {
-    const obj = defineType({ id: "123" })({ color: "red", isFavorite: false });
-    const k = keys(obj);
-
-    expect(k).toHaveLength(3);
-    expect(k).toContain("id");
-    expect(k).toContain("color");
-    expect(k).toContain("isFavorite");
-
-    type cases = [Expect<Equal<typeof k, ("color" | "id" | "isFavorite")[]>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-
-  it("with object and exclusion keys, type and run-time are correct", () => {
-    const obj = defineType({ id: "123" })({ color: "red", isFavorite: false });
-    const k = keys(obj, "color", "id");
-
-    expect(k).toHaveLength(1);
-    expect(k).toContain("isFavorite");
-
-    type cases = [Expect<Equal<typeof k, "isFavorite"[]>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-});

package/tests/kv/kv-spec.ts

@@ -1,20 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { keys, kv } from "src/runtime";
-
-describe("kv utils", () => {
-  it("simple assignment works with strong literal support", () => {
-    const t1 = kv("foo", { a: 1, b: 2, c: "hi" });
-    const t2 = kv("bar", true);
-
-    expect(typeof t1).toBe("object");
-    expect(typeof t2).toBe("object");
-
-    expect(keys(t1)).toContain("foo");
-    expect(t1.foo.a).toBe(1);
-    expect(t1.foo.c).toBe("hi");
-
-    expect(keys(t2)).toContain("bar");
-    expect(t2.bar).toBe(true);
-  });
-});

package/tests/lists/First.test.ts

@@ -1,43 +0,0 @@
-import { describe, it } from "vitest";
-import type { Expect, Equal } from "@type-challenges/utils";
-import { AfterFirst, First } from "src/types/lists";
-
-describe("First<T>, AfterFirst<T>", () => {
-  it("First<T> with literals", () => {
-    const arr = ["one", "two", 42] as const;
-    type F = First<typeof arr>;
-    type cases = [Expect<Equal<F, "one">>];
-    const cases: cases = [true];
-  });
-  it("First<T> with wide types but literal array", () => {
-    const arr = ["one" as string, "two", 42] as const;
-    type F = First<typeof arr>;
-    type cases = [Expect<Equal<F, string>>];
-    const cases: cases = [true];
-  });
-  it("First<T> with a non const array", () => {
-    const arr = ["one", "two", 42];
-    type F = First<typeof arr>;
-    type cases = [Expect<Equal<F, string | number>>];
-    const cases: cases = [true];
-  });
-
-  it("AfterFirst<T> with literals", () => {
-    const arr = ["one", "two", 42] as const;
-    type AF = AfterFirst<typeof arr>;
-    type cases = [Expect<Equal<AF, ["two", 42]>>];
-    const cases: cases = [true];
-  });
-  it("AfterFirst<T> with wide types but literal array", () => {
-    const arr = ["one", "two" as string, 42] as const;
-    type AF = AfterFirst<typeof arr>;
-    type cases = [Expect<Equal<AF, [string, 42]>>];
-    const cases: cases = [true];
-  });
-  it("AfterFirst<T> with a non const array", () => {
-    const arr = ["one", "two", 42];
-    type AF = AfterFirst<typeof arr>;
-    type cases = [Expect<Equal<AF, (string | number)[]>>];
-    const cases: cases = [true];
-  });
-});

package/tests/lists/Length.test.ts

@@ -1,19 +0,0 @@
-import { Equal, Expect } from "@type-challenges/utils";
-import { Length } from "src/types";
-import { describe, it } from "vitest";
-
-describe("Length<T>", () => {
-  it("happy-path", () => {
-    const a1 = [1, 2, 3] as const;
-    const a2 = [1, 2, 3, 4, 5, 6] as const;
-    type A1 = typeof a1;
-    type A2 = typeof a2;
-
-    type cases = [
-      //
-      Expect<Equal<Length<A1>, 3>>,
-      Expect<Equal<Length<A2>, 6>>
-    ];
-    const cases: cases = [true, true];
-  });
-});

package/tests/lists/Split.test.ts

@@ -1,29 +0,0 @@
-import { describe, it } from "vitest";
-import type { Expect, Equal } from "@type-challenges/utils";
-import { Split } from "src/types/lists";
-
-describe("Split<T, SEP>", () => {
-  it("Split<T, SEP> with string literals", () => {
-    const str = "hello world, nice to meet you" as const;
-    type S = Split<typeof str, " ">;
-
-    type cases = [Expect<Equal<S, ["hello", "world,", "nice", "to", "meet", "you"]>>];
-    const cases: cases = [true];
-  });
-
-  it("Split<T, SEP> where string and separator are same", () => {
-    const str = "hello world, 42 nice to meet you" as const;
-    type S = Split<typeof str, typeof str>;
-
-    type cases = [Expect<Equal<S, []>>];
-    const cases: cases = [true];
-  });
-
-  it("Split<T, SEP> string is wide type", () => {
-    const str = "hello world, 42 nice to meet you" as string;
-    type S = Split<typeof str, ",">;
-
-    type cases = [Expect<Equal<S, string[]>>];
-    const cases: cases = [true];
-  });
-});

package/tests/lists/UniqueForProp.spec.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Expect, Equal } from "@type-challenges/utils";
-import { UniqueForProp } from "src/types/lists";
-
-const narrow_data = [
-  { id: 123, color: "blue" },
-  { id: 456, color: "red" },
-] as const;
-type NarrowData = typeof narrow_data;
-
-type R = { id: number; color: string };
-const wide_data: readonly R[] = [
-  { id: 123, color: "blue" },
-  { id: 456, color: "red" },
-];
-type WideData = typeof wide_data;
-
-type R2<T extends string> = Readonly<{ id: number; color: T }>;
-const hybrid = <H extends R2<any>>(...data: H[]): readonly H[] => data;
-const hybrid_data = hybrid(
-  ...[
-    { id: 123, color: "blue" },
-    { id: 456, color: "red" },
-  ]
-);
-type HybridData = typeof hybrid_data;
-
-describe("UniqueForProp<T, P>", () => {
-  it("narrow data works as expected", () => {
-    type U = UniqueForProp<NarrowData, "id">;
-
-    type cases = [
-      // the expected keys are part of the union
-      Expect<Equal<U, 123 | 456>>
-    ];
-
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("wide data only knows the wide type", () => {
-    type U = UniqueForProp<WideData, "id">;
-
-    type cases = [
-      // the keys are rolled up the wide type
-      Expect<Equal<U, number>>
-    ];
-
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-
-  it("wide data only knows the wide type", () => {
-    type U = UniqueForProp<HybridData, "id">;
-    type cases = [Expect<Equal<U, number>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-});

package/tests/lists/asArray.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { AsArray, asArray } from "src/runtime";
-import { Equal, Expect } from "@type-challenges/utils";
-
-describe("AsArray<T>", () => {
-  it("happy path", () => {
-    type T1 = AsArray<4>;
-    type T2 = AsArray<4, true>;
-    type T3 = AsArray<[4, 5, 6]>;
-    type T4 = AsArray<[4, 5, 6], true>;
-
-    type cases = [
-      //
-      Expect<Equal<T1, 4[]>>,
-      Expect<Equal<T2, number[]>>,
-      Expect<Equal<T3, [4, 5, 6]>>,
-      Expect<Equal<T4, number[]>>
-    ];
-    const cases: cases = [true, true, true, true];
-  });
-});
-
-describe("asArray() function", () => {
-  it("non-array is returned as an array", () => {
-    const i = "a";
-    const o = asArray(i);
-    type O = typeof o;
-
-    // run-time
-    expect(o).toEqual(["a"]);
-    // design-time
-    type cases = [Expect<Equal<O, string[]>>];
-    const cases: cases = [true];
-  });
-
-  it("array is returned as an array", () => {
-    const i = ["a"];
-    const o = asArray(i);
-    type O = typeof o;
-
-    // run-time
-    expect(o).toEqual(["a"]);
-    // design-time
-    type cases = [Expect<Equal<O, string[]>>];
-    const cases: cases = [true];
-  });
-
-  it("non-array literal is returned as an array", () => {
-    const i = "a" as const;
-    const o = asArray(i, false);
-    const o2 = asArray(i, true);
-
-    type O = typeof o;
-    type O2 = typeof o2;
-
-    // run-time
-    expect(o).toEqual(["a"]);
-    // design-time
-    type cases = [
-      Expect<Equal<O, "a"[]>>, //
-      Expect<Equal<O2, string[]>>
-    ];
-    const cases: cases = [true, true];
-  });
-
-  it("handling non-array element which presents as undefined", () => {
-    type T = string | undefined;
-    const i = undefined;
-    const i2: T = undefined;
-    const o = asArray(i);
-    const o2 = asArray(i2 as T);
-    const o3 = asArray(i2 as T, false);
-    type O = typeof o;
-    type O2 = typeof o2;
-    type O3 = typeof o3;
-
-    // run-time
-    expect(o).toEqual([]);
-    expect(o2).toEqual([]);
-    // design-time
-    type cases = [
-      Expect<Equal<O, unknown[]>>, //
-      // TODO: would be nice to extract the unknown[] part of the union
-      Expect<Equal<O2, unknown[] | string[]>>,
-      Expect<Equal<O3, unknown[] | string[]>>
-    ];
-    const cases: cases = [true, true, true];
-  });
-
-  it("handling array element which contains undefined is unaffected", () => {
-    type T = string | undefined;
-    const i = [undefined, "foobar"];
-    const i2: T[] = [undefined, "foobar"];
-    const o = asArray(i);
-    const o2 = asArray(i2 as T[]);
-    type O = typeof o;
-    type O2 = typeof o2;
-
-    // run-time
-    expect(o).toEqual([undefined, "foobar"]);
-    expect(o2).toEqual([undefined, "foobar"]);
-    // design-time
-    type cases = [
-      Expect<Equal<O, (string | undefined)[]>>, //
-      Expect<Equal<O2, T[]>>
-    ];
-    const cases: cases = [true, true];
-  });
-});

package/tests/lists/dictArr.test.ts

@@ -1,110 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { Expect, Equal } from "@type-challenges/utils";
-import { dictArr, keys, literal } from "src/runtime";
-
-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 literalArr = [
-  literal({ id: 1, name: "foo", title: "one", cost: 15 }),
-  literal({ id: 2, name: "bar", title: "one" }),
-  literal({ id: 3, name: "baz", title: "two", cost: 45, color: "green" }),
-];
-
-const wideArr = [
-  { id: 1, name: "foo", title: "one", cost: 15 },
-  { id: 2, name: "bar", title: "one" },
-  { id: 3, name: "baz", title: "two", cost: 45, color: "green" },
-];
-
-describe("dictArr() utility API", () => {
-  it("returns an API when passed the array", () => {
-    const r = dictArr(...genericArr);
-    type R = typeof r;
-    // runtime checks
-    expect(typeof r.toLookup).contains("function");
-    expect(typeof r.unique).contains("function");
-    expect(typeof r.count).contains("function");
-    expect(typeof r.sum).contains("function");
-    expect(typeof r.length).contains("number");
-
-    // type checks
-    type ToLookupParam = Parameters<R["toLookup"]>[0];
-    type UniqueParam = Parameters<R["unique"]>[0];
-    type CountParam = Parameters<R["count"]>[0];
-    type SumParam = Parameters<R["sum"]>[0];
-
-    // type ToLookupReturn = ReturnType<R["toLookup"]>;
-
-    type cases = [
-      Expect<Equal<ToLookupParam, "name" | "title">>,
-      Expect<Equal<UniqueParam, "id" | "name" | "title" | "cost" | "color">>,
-      Expect<Equal<CountParam, "cost" | "color">>,
-      Expect<Equal<SumParam, "id" | "cost">>
-    ];
-    const cases: cases = [true, true, true, true];
-  });
-
-  it("toLookup() creates type-strong lookup", () => {
-    const g = dictArr(...genericArr);
-    const l = dictArr(...literalArr);
-    const pl = dictArr(...wideArr);
-    const byNameG = g.toLookup("name");
-    const byNameL = l.toLookup("name");
-    const byNamePL = pl.toLookup("name");
-    const kg = keys(byNameG);
-    const kl = keys(byNameL);
-    const kpl = keys(byNamePL);
-    expect(kg).contains("foo");
-    expect(kg).contains("bar");
-    expect(kg).contains("baz");
-
-    expect(kl).contains("foo");
-    expect(kl).contains("bar");
-    expect(kl).contains("baz");
-
-    expect(kpl).contains("foo");
-    expect(kpl).contains("bar");
-    expect(kpl).contains("baz");
-
-    const fooG = genericArr.find((i) => i.name === "foo");
-    expect(byNameG.foo).toEqual(fooG);
-
-    const fooL = literalArr.find((i) => i.name === "foo");
-    expect(byNameL.foo).toEqual(fooL);
-  });
-
-  it("summarization works", () => {
-    const r = dictArr(...genericArr);
-    expect(r.sum("cost")).toBe(60);
-  });
-
-  it("counting of non-required props works", () => {
-    const r = dictArr(...genericArr);
-    expect(r.count("color")).toBe(1);
-    expect(r.count("cost")).toBe(2);
-  });
-
-  it("uniqueness", () => {
-    const r = dictArr(...genericArr);
-    const color = r.unique("color");
-    const title = r.unique("title");
-
-    expect(color.isUnique).toBeTruthy();
-    expect(color.includedUndefined).toBeTruthy();
-    expect(color.values).toEqual([undefined, "green"]);
-    expect(title.isUnique).toBeFalsy();
-    expect(title.values).toEqual(["one", "two"]);
-  });
-});

package/tests/literal-spec.ts

@@ -1,82 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { idLiteral, literal } from "../src/runtime";
-import { Equal, NotEqual, Expect, ExpectExtends, ExpectFalse } from "@type-challenges/utils";
-
-describe("literal enforcement", () => {
-  it("idLiteral forces 'id' to literal number", () => {
-    const t1 = { id: 1, message: "t1" };
-    const t2 = { id: 2, message: "t2" };
-    type T1 = typeof t1.id;
-    type T2 = typeof t2.id;
-
-    const l1 = idLiteral({ id: 1, message: "t1" });
-    const l2 = idLiteral({ id: 2, message: "t2" });
-    type L1 = typeof l1.id;
-    type L2 = typeof l2.id;
-
-    expect(typeof l1.id).toBe("number"); // run time type of "number"
-    expect(typeof l2.id).toBe("number"); // run time type of "number"
-
-    type cases = [
-      Expect<Equal<T1, T2>>, // without using explicit cast to literal, TS sees as equivalent
-      Expect<NotEqual<L1, L2>>, // TS types, are literals and therefore not equal
-      Expect<NotEqual<L1, number>>,
-      Expect<NotEqual<L2, number>>
-    ];
-    const typeTests: cases = [true, true, true, true];
-    expect(typeTests).toBe(typeTests);
-  });
-
-  it("An array records from idLiteral() is typed as an array of 'id' literals", () => {
-    const l1 = idLiteral({ id: 1, message: "t1" });
-    const l2 = idLiteral({ id: 2, message: "t2" });
-    const arr = [l1, l2];
-    type L1 = typeof arr[0]["id"];
-    type L2 = typeof arr[1]["id"];
-    type NonIndexedId = 3;
-
-    // run-time type is maintained
-    for (const item of arr) {
-      expect(typeof item.id).toBe("number");
-    }
-
-    // real test is literals being accumulated rather than being widened up to "number"
-    type cases = [
-      Expect<Equal<L1, L2>>,
-      Expect<NotEqual<L1, NonIndexedId>>,
-      Expect<NotEqual<L1, number>>,
-      Expect<NotEqual<L2, number>>
-    ];
-    const typeTests: cases = [true, true, true, true];
-    expect(typeTests).toBe(typeTests);
-  });
-
-  it("literal() creates narrow type definitions for all props on passed in object", () => {
-    /** by default you get a wide definition of types */
-    const wide = { foo: 1, bar: false, baz: "hi" };
-    type Wide = typeof wide;
-    /** but with the literal function we can force this to narrow */
-    const narrow = literal({ foo: 1, bar: false, baz: "hi" });
-    type Narrow = typeof narrow;
-    /**
-     * would be nice if this worked but it doesn't; once the type is set, it's set
-     */
-    const nope = literal(wide);
-    type Nope = typeof nope;
-
-    type cases = [
-      Expect<Equal<Wide, { foo: number; bar: boolean; baz: string }>>,
-      Expect<Equal<Narrow, { foo: 1; bar: false; baz: "hi" }>>,
-      // Narrow _does_ extend the Wide definition
-      Expect<ExpectExtends<Wide, Narrow>>,
-      // but the opposite is not true
-      ExpectFalse<ExpectExtends<Narrow, Wide>>,
-      // now unfortunately, using literal() on a variable who's type
-      // has already been inferred does not get us to Narrow
-      Expect<Equal<Wide, Nope>>
-    ];
-    const cases: cases = [true, true, true, false, true];
-    expect(cases).toBe(cases);
-  });
-});

package/tests/literals/AllCaps.spec.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect } from "@type-challenges/utils";
-import { AllCaps } from "src/types";
-
-describe("AllCaps<T> type utility", () => {
-  it("finds AllCaps where it exists", () => {
-    type T1 = AllCaps<"YUP">;
-    type T2 = AllCaps<"YUP ">;
-    type T3 = AllCaps<"YUP YUP YESSSSSSSSSSSSSS">;
-
-    type cases = [Expect<Equal<T1, true>>, Expect<Equal<T2, true>>, Expect<Equal<T3, true>>];
-    const c: cases = [true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("correctly identifies the absence of AllCaps", () => {
-    type T1 = AllCaps<"Nope">;
-    type T2 = AllCaps<"  noo nooo noooooooooooooo">;
-
-    type cases = [Expect<Equal<T1, false>>, Expect<Equal<T2, false>>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("when passed a non literal string, returns 'unknown'", () => {
-    type T1 = AllCaps<string>;
-
-    type cases = [Expect<Equal<T1, "unknown">>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-});