inferred-types 0.37.0 → 0.37.1

package/tests/literals/box.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Equal, Expect } from "@type-challenges/utils";
-import { Box, box, BoxedFnParams, BoxValue, unbox } from "src/runtime";
-import { First } from "src/types/lists/First";
-
-// [Instantiation Expressions](https://devblogs.microsoft.com/typescript/announcing-typescript-4-7-beta/#instantiation-expressions)
-
-// this exercise was started around the time that Instantiation expressions
-// were first introduced and with the hope that this would help narrow functions
-// which have an inner generic that provides narrow typing.
-
-describe("boxing / unboxing", () => {
-  it("box a function with generic", () => {
-    const fn = <T extends string>(i: T) => `Hello ${i}` as const;
-    const b = box(fn);
-    const globalUnbox = unbox(b);
-    type UB = typeof globalUnbox;
-    const usingValue = b.value("foo");
-    const unboxedNarrow = b.unbox("foo");
-    const unboxedWide = b.unbox("foo" as string);
-
-    const bn = box(42);
-    type BN = typeof bn;
-    const rn = bn.unbox();
-    type RN = typeof rn;
-    const rn2 = bn.value;
-    type RN2 = typeof rn2;
-
-    type Hybrid = 42 | 56 | typeof fn;
-    const h = box(42 as Hybrid);
-    type H = typeof h;
-    type HV = H["value"];
-
-    // runtime
-    expect(typeof b).toBe("object");
-    expect(
-      typeof globalUnbox,
-      `using unbox(fn) should have returned function: ${globalUnbox}`
-    ).toBe("function");
-    expect(usingValue).toBe("Hello foo");
-    expect(unboxedNarrow).toBe("Hello foo");
-    expect(unboxedWide).toBe("Hello foo");
-
-    expect(rn).toBe(42);
-    expect(rn2).toBe(42);
-
-    // type tests
-    type B = typeof b;
-    type BV = BoxValue<B>;
-    type BF = First<BoxedFnParams<B>>;
-
-    type cases = [
-      // FUNCTIONS
-      Expect<Equal<B, Box<typeof fn>>>,
-      Expect<Equal<BV, typeof fn>>, //
-      Expect<Equal<BF, string>>,
-      /** unboxing fn results in same fn including generics */
-      Expect<Equal<UB, typeof fn>>,
-      /** this uses the VALUE prop and provides the TARGET resolution for unbox */
-      Expect<Equal<typeof usingValue, "Hello foo">>,
-      /**
-       * using the passthrough feature of `b.unbox(val)` we would ideally like to
-       * get same narrow type as test above but it is reduced to an "ok" level for
-       * now
-       */
-      Expect<Equal<typeof unboxedNarrow, `Hello ${string}`>>,
-      /**
-       * Note, however, that the wide value of string passed in resolves in the same
-       * manner which helps to point to where resolution is being lost
-       */
-      Expect<Equal<typeof unboxedWide, `Hello ${string}`>>,
-
-      // NUMBER BOXes
-      Expect<Equal<BN, Box<42>>>,
-      /** unboxing preserves numeric literal */
-      Expect<Equal<RN, 42>>,
-      /** can pick off the value prop for same type */
-      Expect<Equal<RN2, 42>>,
-
-      // HYBRID
-      Expect<Equal<HV, Hybrid>>
-    ];
-    const cases: cases = [true, true, true, true, true, true, true, true, true, true, true];
-  });
-});

package/tests/literals/whitespace-capture.spec.ts

@@ -1,60 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect } from "@type-challenges/utils";
-import { LeftWhitespace, RightWhitespace } from "src/types";
-
-describe("LeftWhitespace<T> utility", () => {
-  it("no whitespace results in empty string literal", () => {
-    type T1 = LeftWhitespace<"foobar">;
-    type T2 = LeftWhitespace<"foobar \n">;
-
-    type cases = [Expect<Equal<T1, "">>, Expect<Equal<T2, "">>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("left whitespace is captured from string literal, right whitespace ignored", () => {
-    type T1 = LeftWhitespace<" foobar">;
-    type T2 = LeftWhitespace<"\n\t foobar \n">;
-
-    type cases = [Expect<Equal<T1, " ">>, Expect<Equal<T2, "\n\t ">>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("a 'string' type passed in returns a string", () => {
-    type T1 = LeftWhitespace<string>;
-
-    type cases = [Expect<Equal<T1, string>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-});
-
-describe("RightWhitespace<T> utility", () => {
-  it("no whitespace results in empty string literal", () => {
-    type T1 = RightWhitespace<"foobar">;
-    type T2 = RightWhitespace<"\n\tfoobar">;
-
-    type cases = [Expect<Equal<T1, "">>, Expect<Equal<T2, "">>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("right whitespace is captured from string literal, left whitespace ignored", () => {
-    type T1 = RightWhitespace<"foobar ">;
-    type T2 = RightWhitespace<"\n\t foobar \n">;
-
-    type cases = [Expect<Equal<T1, " ">>, Expect<Equal<T2, " \n">>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("a 'string' type passed in returns a string", () => {
-    type T1 = RightWhitespace<string>;
-
-    type cases = [Expect<Equal<T1, string>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-});

package/tests/mapValues-spec.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { mapValues, literal } from "../src/runtime";
-import type { Expect, Equal, ExpectFalse } from "@type-challenges/utils";
-
-describe("mapValues() utility", () => {
-  it("simple transform while maintaining wide type through transform", () => {
-    const colors = { red: 4, blue: 2, green: 3 };
-    const x2 = mapValues(colors, (v) => v * 2);
-
-    expect(x2.red).toBe(colors.red * 2);
-    expect(x2.blue).toBe(colors.blue * 2);
-    expect(x2.green).toBe(colors.green * 2);
-
-    type cases = [
-      // although not always the case, because the value
-      // isn't changed in it's type properties they are
-      // equal in _type_ after transform
-      Expect<Equal<typeof colors, typeof x2>>,
-      // what always should be true is that both dictionaries
-      // share the same keys
-      Expect<Equal<keyof typeof colors, keyof typeof x2>>
-    ];
-    const cases: cases = [true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("simple transform but with input type set to literals", () => {
-    const colors = literal({ red: 4, blue: 2, green: 3 });
-    const x2 = mapValues(colors, (v) => v * 2);
-
-    expect(x2.red).toBe(colors.red * 2);
-    expect(x2.blue).toBe(colors.blue * 2);
-    expect(x2.green).toBe(colors.green * 2);
-
-    type cases = [
-      // by making the initial type take on literal values
-      // instead of generalizing to "number" we no longer
-      // have equality of types after the transform
-      ExpectFalse<Equal<typeof colors, typeof x2>>,
-      // note that the transformed values are wide,
-      // unlike the input to the process
-      Expect<Equal<typeof x2["blue"], number>>,
-      // As always, the keys remain the same
-      Expect<Equal<keyof typeof colors, keyof typeof x2>>
-    ];
-    const cases: cases = [false, true, true];
-    expect(cases).toBe(cases);
-  });
-});

package/tests/props-spec.ts

@@ -1,234 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import type { Expect, Equal } from "@type-challenges/utils";
-import {
-  KeysWithValue,
-  OptionalKeys,
-  RequiredKeys,
-  RequiredProps,
-  WithValue,
-  WithStringKeys,
-  StringKeys,
-  NumericKeys,
-  NonStringKeys,
-  WithNumericKeys,
-} from "src/types/dictionary/props";
-
-type T0 = { foo: number; bar: number; baz: string };
-type T1 = { foo: number; bar: number; baz?: string };
-type T2 = { foo: number; bar?: number; baz?: string };
-type T3 = { foo?: number; bar?: number; baz?: string };
-
-describe("Dictionary Type Utils", () => {
-  it("RequiredKeys<T> extracts the right keys", () => {
-    type cases = [
-      Expect<Equal<RequiredKeys<T0>, "foo" | "bar" | "baz">>,
-      Expect<Equal<RequiredKeys<T1>, "foo" | "bar">>,
-      Expect<Equal<RequiredKeys<T2>, "foo">>,
-      Expect<Equal<RequiredKeys<T3>, never>>
-    ];
-    const cases: cases = [true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("OptionalKeys<T> extracts the right keys", () => {
-    type cases = [
-      Expect<Equal<OptionalKeys<T0>, never>>,
-      Expect<Equal<OptionalKeys<T1>, "baz">>,
-      Expect<Equal<OptionalKeys<T2>, "baz" | "bar">>,
-      Expect<Equal<OptionalKeys<T3>, "foo" | "bar" | "baz">>
-    ];
-    const cases: cases = [true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("OptionalKeys<T> extracts the right keys", () => {
-    type cases = [
-      Expect<Equal<OptionalKeys<T0>, never>>,
-      Expect<Equal<OptionalKeys<T1>, "baz">>,
-      Expect<Equal<OptionalKeys<T2>, "baz" | "bar">>,
-      Expect<Equal<OptionalKeys<T3>, "foo" | "bar" | "baz">>
-    ];
-    const cases: cases = [true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("RequiredProps<T> extracts the KV's", () => {
-    type cases = [
-      Expect<Equal<RequiredProps<T0>, T0>>,
-      Expect<Equal<RequiredProps<T1>, Omit<T0, "baz">>>,
-      Expect<Equal<RequiredProps<T2>, Omit<T2, "baz" | "bar">>>,
-      Expect<Equal<RequiredProps<T3>, Omit<T3, "foo" | "bar" | "baz">>>
-    ];
-    const cases: cases = [true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  type LiteralType = {
-    foo: 1;
-    foo2: number;
-    bar: true;
-    baz: false;
-    baz2: false;
-    wide: boolean;
-    greet: "hi";
-  };
-
-  const narrowType = { foo: 1, foo2: 2, bar: true, baz: false, baz2: false, greet: "hi" } as const;
-  type NarrowType = typeof narrowType;
-  const wideType = { foo: 1, foo2: 2, bar: true, baz: false, baz2: false, greet: "hi" };
-  type WideType = typeof wideType;
-
-  it("KeysWithValue<type, obj> identifies keys of the given object which have a value of specified type", () => {
-    type SL = KeysWithValue<string, LiteralType>;
-    type SN = KeysWithValue<string, NarrowType>;
-    type SW = KeysWithValue<string, WideType>;
-
-    type StrLiteralNarrow = KeysWithValue<"hi", NarrowType>;
-    type StrLiteralWide = KeysWithValue<"hi", WideType>;
-
-    type Num = KeysWithValue<number, LiteralType>;
-    type NumNarrow = KeysWithValue<number, NarrowType>;
-    type NumWide = KeysWithValue<number, WideType>;
-
-    type LT = KeysWithValue<true, LiteralType>;
-    type LF = KeysWithValue<false, LiteralType>;
-    type LB = KeysWithValue<boolean, LiteralType>;
-
-    type TrueNarrow = KeysWithValue<true, NarrowType>;
-    type TrueWide = KeysWithValue<true, WideType>;
-
-    type BooleanNarrow = KeysWithValue<boolean, NarrowType>;
-    type BooleanWide = KeysWithValue<boolean, WideType>;
-
-    type cases = [
-      Expect<Equal<SL, "greet">>,
-      Expect<Equal<SN, "greet">>,
-      Expect<Equal<SW, "greet">>,
-
-      // the type "hi" IS matched with a narrow type definition
-      Expect<Equal<StrLiteralNarrow, "greet">>,
-      // the type "hi" is not matched to the wider type string
-      Expect<Equal<StrLiteralWide, never>>,
-
-      Expect<Equal<Num, "foo" | "foo2">>,
-      Expect<Equal<NumNarrow, "foo" | "foo2">>,
-      Expect<Equal<NumWide, "foo" | "foo2">>,
-
-      Expect<Equal<LT, "bar">>,
-      Expect<Equal<LF, "baz" | "baz2">>,
-      Expect<Equal<LB, "bar" | "baz" | "baz2" | "wide">>,
-
-      // the literal type "true" can be matched when dealing a literal type
-      Expect<Equal<TrueNarrow, "bar">>,
-      // but no keys are matched when the key's value has been broadened to "boolean"
-      Expect<Equal<TrueWide, never>>,
-      // regardless of whether a type is `true`, `false`, or `boolean` they all
-      // match up with the `boolean` type
-      Expect<Equal<BooleanNarrow, "bar" | "baz" | "baz2">>,
-      Expect<Equal<BooleanWide, "bar" | "baz" | "baz2">>
-    ];
-    const cases: cases = [
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-      true,
-    ];
-    expect(cases).toBe(cases);
-  });
-
-  it("WithValue<type, obj> reduces the types on the object effectively", () => {
-    type Literal = { foo: 1; bar: true; baz: false; baz2: false };
-
-    type S = WithValue<string, T0>;
-    type N = WithValue<number, T0>;
-    type LT = WithValue<true, Literal>;
-    type LF = WithValue<false, Literal>;
-
-    type cases = [
-      Expect<Equal<S, { baz: string }>>,
-      Expect<Equal<N, { foo: number; bar: number }>>,
-      Expect<Equal<LT, { bar: true }>>,
-      Expect<Equal<LF, { baz: false; baz2: false }>>
-    ];
-    const cases: cases = [true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("WithValue<type, obj> reduces the non-literal types from typeof", () => {
-    const t = { foo: 1, bar: true, baz: false, baz2: false, xyz: "hi" };
-    type T = typeof t;
-
-    type S = WithValue<string, T>;
-    type N = WithValue<number, T>;
-    type B = WithValue<boolean, T>;
-
-    type cases = [
-      Expect<Equal<S, { xyz: string }>>,
-      Expect<Equal<N, { foo: number }>>,
-      Expect<Equal<B, { bar: boolean; baz: boolean; baz2: boolean }>>
-    ];
-    const cases: cases = [true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("WithValue<t,o> reduces to literal types when runtime var set as 'const'", () => {
-    const t = { foo: 1, bar: true, baz: false, baz2: false, xyz: "hi" } as const;
-    type T = typeof t;
-
-    type S = WithValue<string, T>;
-    type N = WithValue<number, T>;
-    type F = WithValue<false, T>;
-
-    type cases = [
-      Expect<Equal<S, { readonly xyz: "hi" }>>,
-      Expect<Equal<N, { readonly foo: 1 }>>,
-      Expect<Equal<F, { readonly baz: false; readonly baz2: false }>>
-    ];
-    const cases: cases = [true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("WithValue<Function, O> reduces to kv's with a function but retains functions signatuer", () => {
-    type T = WithValue<Function, { a: number; b: string; c: () => "hello"; d: () => "world" }>;
-
-    type cases = [Expect<Equal<T, { c: () => "hello"; d: () => "world" }>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-
-  it("WithStringKeys<T> and WithNumericKeys<T> reduce type to appropriate subset", () => {
-    const t1 = { foo: 456, bar: "hi", 1: "a number", 2: "another pesky number" };
-    type T1 = typeof t1;
-    type SK = StringKeys<T1>;
-    type NK = NumericKeys<T1>;
-    type NonString = NonStringKeys<T1>;
-    type StringKeysOnly = WithStringKeys<T1>;
-    type NumericKeysOnly = WithNumericKeys<T1>;
-
-    type cases = [
-      // the building blocks is being able to determine the string
-      // and numeric keys on an object
-      Expect<Equal<SK, "foo" | "bar">>,
-      Expect<Equal<NK, 1 | 2>>,
-      Expect<Equal<NonString, 1 | 2>>,
-      // they key based primitives allows us to to then just ask
-      // for the object with only string-based keys represented
-      Expect<Equal<StringKeysOnly, { foo: number; bar: string }>>,
-      Expect<Equal<NumericKeysOnly, { 1: string; 2: string }>>
-    ];
-    const cases: cases = [true, true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-});

package/tests/runtime/condition.spec.ts

@@ -1,19 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { condition, isFunction, isTrue } from "src/runtime";
-
-describe("condition() utility", () => {
-  it("basic type checks through condition abstraction", () => {
-    const trueIsTrue = condition(isTrue, true);
-    const falseAintTrue = condition(isTrue, false);
-    const simpleFnIsAFunction = condition(isFunction, () => "hello world");
-
-    // run time
-    expect(trueIsTrue).toBe(true);
-    expect(falseAintTrue).toBe(false);
-    expect(simpleFnIsAFunction).toBe(true);
-
-    // typing
-
-    //TODO: get this working!
-  });
-});