inferred-types 0.36.4 → 0.37.1

package/tests/runtime/if-is.spec.ts

@@ -1,390 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { Expect, Equal } from "@type-challenges/utils";
-import {
-  ifArray,
-  ifArrayPartial,
-  ifBoolean,
-  ifNumber,
-  ifSameType,
-  ifString,
-  ifTrue,
-  ifUndefined,
-  isTrue,
-} from "src/runtime/type-checks";
-import { EndsWith, Extends, LowerAlpha, Or, StartsWith } from "src/types";
-import { ifStartsWith, startsWith } from "src/runtime/type-checks/startsWith";
-import { box, wide } from "src/runtime/literals";
-import { or } from "src/runtime";
-
-describe("runtime if/is", () => {
-  it("ifString(v,i,e)", () => {
-    const t = ifString("foo", () => 42, false);
-    const f = ifString(-1, () => "yikes", 42);
-
-    type cases = [
-      Expect<Equal<typeof t, 42>>, //
-      Expect<Equal<typeof f, 42>> //
-    ];
-    const cases: cases = [true, true];
-  });
-
-  it("ifNumber(v,i,e)", () => {
-    const t = ifNumber(42, 42, false);
-    const f = ifNumber("foo", "yikes", 42);
-
-    type cases = [
-      Expect<Equal<typeof t, 42>>, //
-      Expect<Equal<typeof f, 42>> //
-    ];
-    const cases: cases = [true, true];
-  });
-
-  it("ifBoolean(v,i,e)", () => {
-    const t = ifBoolean(false, 42, false);
-    const f = ifBoolean(undefined, "yikes", 42);
-
-    type cases = [
-      Expect<Equal<typeof t, 42>>, //
-      Expect<Equal<typeof f, 42>> //
-    ];
-    const cases: cases = [true, true];
-  });
-
-  it("ifTrue(v,i,e)", () => {
-    const t = ifTrue(true as true, 42, false);
-    const f = ifTrue(false, "yikes", 42);
-    const f2 = ifTrue(true as boolean, "yikes", 42);
-
-    type cases = [
-      Expect<Equal<typeof t, 42>>, //
-      Expect<Equal<typeof f, 42>>, //
-      Expect<Equal<typeof f2, "yikes" | 42>> //
-    ];
-    const cases: cases = [true, true, true];
-  });
-
-  it("ifTrue(v,i,e) with boxed functions", () => {
-    const f1 = box(<T extends string>(input: T) => `Hello ${input}` as const);
-    const f2 = box(<T extends string>(input: T) => `Get out ${input}!` as const);
-    const t = <T extends string, B extends boolean>(i: T, nice: B) => {
-      return isTrue(nice) ? f1.value(i) : f2.value(i);
-    };
-    const t2 = <T extends string, B extends boolean>(i: T, nice: B) =>
-      ifTrue(nice, f1.value(i), f2.value(i));
-
-    // both approaches produce correct result
-    const r1 = t("Joe", true);
-    const r2 = t2("Joe", true);
-    expect(r1).toBe("Hello Joe");
-    expect(r2).toBe("Hello Joe");
-
-    // only the "ifTrue" approach resolves fully at design time
-    type R1 = typeof r1;
-    type R2 = typeof r2;
-
-    type cases = [
-      // still get union type with `isTrue` conditional
-      Expect<Equal<R1, "Hello Joe" | "Get out Joe!">>,
-      // but encapsulating both outcomes in `ifTrue` resolves the union
-      Expect<Equal<R2, "Hello Joe">>
-    ];
-    const cases: cases = [true, true];
-  });
-
-  it("ifTrue(v,i,e) with string literal functions", () => {
-    const f1 = <T extends string>(input: T) => `Hello ${input}` as const;
-    const f2 = <T extends string>(input: T) => `Get out ${input}!` as const;
-    const t = <T extends string, B extends boolean>(i: T, nice: B) => {
-      return isTrue(nice) ? f1(i) : f2(i);
-    };
-    const t2 = <T extends string, B extends boolean>(i: T, nice: B) => ifTrue(nice, f1(i), f2(i));
-
-    // both approaches produce correct result
-    const r1 = t("Joe", true);
-    const r2 = t2("Joe", true);
-    expect(r1).toBe("Hello Joe");
-    expect(r2).toBe("Hello Joe");
-
-    // only the "ifTrue" approach resolves fully at design time
-    type R1 = typeof r1;
-    type R2 = typeof r2;
-
-    type cases = [
-      // still get union type with `isTrue` conditional
-      Expect<Equal<R1, "Hello Joe" | "Get out Joe!">>,
-      // but encapsulating both outcomes in `ifTrue` resolves the union
-      Expect<Equal<R2, "Hello Joe">>
-    ];
-    const cases: cases = [true, true];
-  });
-
-  it("Or<T[]> type util", () => {
-    type T1 = Or<[true, true, false]>;
-    type T2 = Or<[false, false, false]>;
-    type T3 = Or<[boolean, boolean, true]>;
-    type T4 = Or<[boolean, boolean, boolean]>;
-
-    type cases = [
-      Expect<Equal<T1, true>>,
-      Expect<Equal<T2, false>>,
-      Expect<Equal<T3, true>>,
-      Expect<Equal<T4, boolean>>
-    ];
-    const cases: cases = [true, true, true, true];
-  });
-
-  it("or() runtime utility", () => {
-    const t1 = or(true, true, false);
-    const t2 = or(false, false, false);
-    const t3 = or(false as boolean, false, true);
-    const t4 = or(false as boolean, false as boolean, true as boolean);
-
-    type cases = [
-      Expect<Equal<typeof t1, true>>,
-      Expect<Equal<typeof t2, false>>,
-      Expect<Equal<typeof t3, true>>,
-      Expect<Equal<typeof t4, boolean>>
-    ];
-    const cases: cases = [true, true, true, true];
-
-    expect(t1).toBe(true);
-    expect(t2).toBe(false);
-    expect(t3).toBe(true);
-    expect(t4).toBe(true);
-  });
-
-  it("Extends<T,EXTENDS> with single clause", () => {
-    type cases = [
-      //
-      Expect<Equal<Extends<1, number>, true>>,
-      Expect<Equal<Extends<2, string>, false>>,
-      Expect<Equal<Extends<2, 2 | 3>, true>>
-    ];
-    const cases: cases = [true, true, true];
-  });
-
-  it("IfExtends<T,EXTENDS,IF,ELSE", () => {
-    type cases = [/** type tests */];
-    const cases: cases = [];
-  });
-
-  it("ifArray(val,if,else) utility", () => {
-    const fn0 = ifArray(
-      "foobar" as string,
-      (i) => `I'm an array, my length is ${i.length}` as const,
-      (i) => `I'm not an array, I am ${i}` as const
-    );
-    const fn1 = ifArray(
-      "foobar",
-      (i) => `I'm an array, my length is ${i.length}` as const,
-      (i) => `I'm not an array, I am ${i}` as const
-    );
-    const fn2 = ifArray(
-      ["foo", "bar"] as const,
-      (i) => `I'm an array, my length is ${i.length}` as const,
-      (i) => `I'm not an array, I am ${i}` as const
-    );
-
-    const fn3 = ifArray(
-      ["foo", "bar"],
-      (i) => `I'm an array, my length is ${i.length}` as const,
-      (i) => `I'm not an array, I am ${i}` as const
-    );
-
-    type cases = [
-      Expect<Equal<typeof fn0, `I'm not an array, I am ${string}`>>,
-      Expect<Equal<typeof fn1, `I'm not an array, I am foobar`>>,
-      Expect<Equal<typeof fn2, `I'm an array, my length is 2`>>,
-      Expect<Equal<typeof fn3, `I'm an array, my length is ${number}`>>
-    ];
-    const cases: cases = [true, true, true, true];
-  });
-
-  it("ifArrayPartial()()", () => {
-    const arrTest = ifArrayPartial<string | string[]>()(
-      (i) => `I'm an array, my length is ${i.length}`,
-      (i) => `I'm not an array, I am ${i}`
-    );
-
-    const t1 = arrTest("Bob");
-    const t2 = arrTest(["foo", "bar"]);
-
-    type cases = [
-      Expect<Equal<typeof t1, `I'm not an array, I am ${string}`>>,
-      Expect<Equal<typeof t2, `I'm an array, my length is ${number}`>>
-    ];
-    const cases: cases = [true, true];
-  });
-
-  it("ifUndefined(v,i,e)", () => {
-    const t = ifUndefined(undefined, 42, false);
-    const f = ifUndefined(false, "yikes", 42);
-    const f2 = ifUndefined("", "yikes", 42);
-
-    type cases = [
-      Expect<Equal<typeof t, 42>>, //
-      Expect<Equal<typeof f, 42>>, //
-      Expect<Equal<typeof f2, 42>> //
-    ];
-    const cases: cases = [true, true, true];
-  });
-
-  it("StartsWith<T,U>", () => {
-    type T1 = StartsWith<"foobar", "foo">;
-    type T2 = StartsWith<"foobar", "foot">;
-    type T3 = StartsWith<"foobar", string>;
-    type T4 = StartsWith<string, "foo">;
-    type T5 = StartsWith<string, string>;
-
-    type T6 = StartsWith<"alpha", LowerAlpha>;
-    type T7 = StartsWith<"Alpha", LowerAlpha>;
-
-    type cases = [
-      Expect<Equal<T1, true>>, //
-      Expect<Equal<T2, false>>,
-      // if either the "start with" or "val" props are wide then we can't resolve at design time
-      Expect<Equal<T3, boolean>>,
-      Expect<Equal<T4, boolean>>,
-      Expect<Equal<T5, boolean>>,
-      // LowerAlpha is a string literal
-      Expect<Equal<T6, true>>,
-      Expect<Equal<T7, false>>
-    ];
-    const cases: cases = [true, true, true, true, true, true, true];
-  });
-
-  it("EndsWith<T,U>", () => {
-    type T1 = EndsWith<"foobar", "bar">;
-    type T2 = EndsWith<"foobar", "bart">;
-    type T3 = EndsWith<"foobar", string>;
-    type T4 = EndsWith<string, "bar">;
-    type T5 = EndsWith<string, string>;
-
-    type cases = [
-      Expect<Equal<T1, true>>, //
-      Expect<Equal<T2, false>>,
-      Expect<Equal<T3, boolean>>,
-      Expect<Equal<T4, boolean>>,
-      Expect<Equal<T5, boolean>>
-    ];
-    const cases: cases = [true, true, true, true, true];
-  });
-
-  it("startsWith(t)(v)", () => {
-    const t1 = startsWith("foo")("foobar");
-    const t2 = startsWith("foot")("foobar");
-    const p1 = startsWith("foo");
-
-    // runtime
-    expect(t1).toBe(true);
-    expect(t2).toBe(false);
-    expect(p1("foot")).toBe(true);
-    expect(p1("bart")).toBe(false);
-
-    // design time
-    type cases = [
-      Expect<Equal<typeof t1, true>>, //
-      Expect<Equal<typeof t2, false>> //
-    ];
-    const cases: cases = [true, true];
-  });
-
-  it("ifStartsWith(start, isTrue, isFalse)(v)", () => {
-    const noSir = <T extends string>(i: T) => `no sir didn't like it ${i}` as const;
-    const startWithFoo = ifStartsWith(
-      // condition
-      "foo",
-      // inline
-      (i) => `welcome ${i}`,
-      // external
-      noSir
-    );
-    const t = startWithFoo("foobar");
-    type T = typeof t;
-    const f = startWithFoo("nope");
-    type F = typeof f;
-
-    type FS = typeof startWithFoo;
-    type RFS = ReturnType<FS>;
-
-    // runtime
-    expect(t).toBe("welcome foobar");
-    expect(f).toBe("no sir didn't like it nope");
-
-    // TODO: get the design time to be more literal
-
-    type cases = [
-      Expect<Equal<T, `welcome ${string}`>>,
-      Expect<Equal<F, `no sir didn't like it ${string}`>>,
-      Expect<
-        Equal<
-          //
-          RFS,
-          `welcome ${string}` | `no sir didn't like it ${string}`
-        >
-      >
-    ];
-    const cases: cases = [true, true, true];
-  });
-
-  it("ifSameType", () => {
-    const t1 = ifSameType(
-      "foo",
-      wide.string,
-      (i) => `Hello ${i}`,
-      (i) => `Goodbye ${i}`
-    );
-    const t2 = ifSameType(
-      42,
-      wide.string,
-      (i) => `Hello ${i}`,
-      (i) => `Goodbye ${i}`
-    );
-    const t3 = ifSameType(
-      "foo" as string,
-      wide.string,
-      (i) => `Hello ${i}`,
-      (i) => `Goodbye ${i}`
-    );
-    const t4 = ifSameType(
-      42 as number,
-      wide.string,
-      (i) => `Hello ${i}`,
-      (i) => `Goodbye ${i}`
-    );
-
-    const nested = ifSameType(
-      false,
-      wide.string,
-      (i) => `Hello ${i}`,
-      (i) =>
-        ifSameType(
-          i,
-          wide.number,
-          (n) => n,
-          (i) =>
-            ifSameType(
-              i,
-              wide.boolean,
-              (b) => `I'm a boolean value of ${b}`,
-              () => ""
-            )
-        )
-    );
-
-    type cases = [
-      // matches (narrow)
-      Expect<Equal<typeof t1, "Hello foo">>,
-      // does not match (narrow)
-      Expect<Equal<typeof t2, `Goodbye 42`>>,
-      // matches (wide)
-      Expect<Equal<typeof t3, `Hello ${string}`>>,
-      // does not match (wide)
-      Expect<Equal<typeof t4, `Goodbye ${number}`>>,
-      // nested
-      Expect<Equal<typeof nested, `I'm a boolean value of false`>>
-    ];
-    const cases: cases = [true, true, true, true, true];
-  });
-});

package/tests/runtime/map-and-convert.test.ts

@@ -1,31 +0,0 @@
-import { Equal, Expect } from "@type-challenges/utils";
-import { createConverter } from "src/runtime/lists/createConverter";
-import { describe, it, expect } from "vitest";
-
-// Note: while type tests fail visible inspection they pass from Vitest
-// standpoint so always be sure to run `tsc --noEmit` over your test files to
-// gain validation that no new type vulnerabilities have cropped up.
-
-describe("createConverter()", () => {
-  it("basic converter setup", () => {
-    const convert = createConverter({
-      string: (s) => `Hello ${s}`,
-      number: (n) => `The number was ${n}`,
-      object: (o) => `An object with keys ${Object.keys(o).join(", ")}`,
-    });
-
-    const t1 = convert("foo");
-    const t2 = convert(42);
-    const t3 = convert({ foo: 42, bar: 12 });
-    expect(t1).toBe("Hello foo");
-    expect(t2).toBe("The number was 42");
-
-    type cases = [
-      // TODO: get the final narrowness resolved ... this should be doable
-      Expect<Equal<typeof t1, `Hello ${string}`>>,
-      Expect<Equal<typeof t2, `The number was ${number}`>>,
-      Expect<Equal<typeof t3, `An object with keys ${string}`>>
-    ];
-    const cases: cases = [true, true, true];
-  });
-});

package/tests/runtime/type.spec.ts

@@ -1,190 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import type { Expect, Equal } from "@type-challenges/utils";
-import { FunctionType } from "src/types";
-import { type, createFnWithProps, isFunction, isObject } from "src/runtime";
-
-describe("testing type() utility and some pre-made conditions", () => {
-  it("isFunction()", () => {
-    const fn = () => "hello world";
-    const fn2 = createFnWithProps(() => "hello world", { foo: "bar" });
-    const t1 = isFunction(fn);
-    const t2 = isFunction(fn2);
-    type T1 = typeof t1;
-    type T2 = typeof t2;
-
-    expect(t1).toBe(true);
-    expect(t2).toBe(true);
-
-    type cases = [
-      // a simple function is correctly typed (no surprise)
-      Expect<Equal<T1, true>>,
-      // but so is a function which has props; using just _typeof_
-      // not work
-      Expect<Equal<T2, true>>
-    ];
-
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("isObject detects object which are not arrays and not functions with props", () => {
-    const fnWithProps = createFnWithProps(() => "hi", { foo: "bar" });
-    const obj = {
-      foo: 1,
-      bar: { left: "left", right: "right" },
-      baz: [1, 2, 3],
-      fnWithProps,
-    } as const;
-
-    const foo = isObject(obj.foo);
-    const bar = isObject(obj.bar);
-    const baz = isObject(obj.baz);
-    const fnWithProps2 = isObject(obj.fnWithProps);
-
-    // run-time
-    expect(foo).toBeFalsy();
-    expect(bar).toBeTruthy();
-    expect(baz).toBeFalsy();
-    expect(fnWithProps2).toBeFalsy();
-
-    // type checking
-    type cases = [
-      // all tests should result in a discrete, literal true/false
-      Expect<Equal<typeof foo, false>>,
-      Expect<Equal<typeof bar, true>>,
-      Expect<Equal<typeof baz, false>>,
-      Expect<Equal<typeof fnWithProps2, false>>
-    ];
-
-    const c: cases = [true, true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("an object can be detected using type() utility", () => {
-    const fnWithProps = createFnWithProps(() => "hi", { foo: "bar" });
-    const obj = {
-      foo: 1,
-      bar: { left: "left", right: "right" },
-      baz: [1, 2, 3],
-      fnWithProps,
-    } as const;
-    const o = type((t) => t.object);
-
-    const foo = o.is(obj.foo);
-    const bar = o.is(obj.bar);
-    const baz = o.is(obj.baz);
-    const fnWithProps2 = o.is(obj.fnWithProps);
-
-    // run-time
-    expect(foo).toBeFalsy();
-    expect(bar).toBeTruthy();
-    expect(baz).toBeFalsy();
-    expect(fnWithProps2).toBeFalsy();
-
-    // type checking
-    type cases = [
-      // all tests should result in a discrete, literal true/false
-      Expect<Equal<typeof foo, false>>,
-      Expect<Equal<typeof bar, true>>,
-      Expect<Equal<typeof baz, false>>,
-      Expect<Equal<typeof fnWithProps2, false>>
-    ];
-
-    const c: cases = [true, true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("defining a boolean type", () => {
-    const b = type((t) => t.boolean);
-
-    type TypeOf = typeof b.type;
-
-    expect(b.name).toBe("boolean");
-
-    const trueTest = b.is(true);
-    const falseTest = b.is(false);
-    const nadaTest = b.is("nada");
-
-    expect(trueTest).toBe(true);
-    expect(falseTest).toBe(true);
-    expect(nadaTest).toBe(false);
-
-    type cases = [
-      //
-      Expect<Equal<TypeOf, boolean>>,
-      Expect<Equal<typeof trueTest, true>>,
-      Expect<Equal<typeof falseTest, true>>,
-      Expect<Equal<typeof nadaTest, false>>
-    ];
-
-    const c: cases = [true, true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("defining true type", () => {
-    const t = type((t) => t.true);
-
-    const typeOf = t.type;
-    type TypeOf = typeof typeOf;
-
-    expect(t.name).toBe("true");
-
-    const trueIsTrue = t.is(true as true);
-    const falseNotTrue = t.is(false as false);
-    const nadaNotTrue = t.is("nada");
-    const b = true as boolean;
-    const booleanUnknown = t.is(b);
-
-    expect(trueIsTrue).toBe(true);
-    expect(falseNotTrue).toBe(false);
-    expect(nadaNotTrue).toBe(false);
-    // run-time can evaluate, but type system not sure
-    expect(booleanUnknown).toBe(true);
-
-    // TODO: return the final type test below to "unknown" versus "boolean" once there's a fix
-
-    type cases = [
-      //
-      Expect<Equal<TypeOf, true>>,
-      Expect<Equal<typeof trueIsTrue, true>>,
-      Expect<Equal<typeof falseNotTrue, false>>,
-      Expect<Equal<typeof nadaNotTrue, false>>,
-      // the type system has no way of knowing
-      // because the wide type of "boolean" is
-      // a union type which includes true
-      Expect<Equal<typeof booleanUnknown, boolean>>
-    ];
-
-    const c: cases = [true, true, true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("defining a function type", () => {
-    const t = type((t) => t.function);
-
-    const typeOf = t.type;
-    type TypeOf = typeof typeOf;
-
-    expect(t.name).toBe("function");
-
-    const basicFn = t.is(() => "hi");
-    const fnWithProps = t.is(createFnWithProps(() => "hi", { foo: "bar" }));
-    const nadaTest = t.is("nada");
-
-    expect(basicFn).toBe(true);
-    expect(fnWithProps).toBe(true);
-    expect(nadaTest).toBe(false);
-
-    type cases = [
-      //
-      Expect<Equal<TypeOf, FunctionType>>,
-      Expect<Equal<typeof basicFn, true>>,
-      Expect<Equal<typeof fnWithProps, true>>,
-      Expect<Equal<typeof nadaTest, false>>
-    ];
-
-    const c: cases = [true, true, true, true];
-    expect(c).toBe(c);
-  });
-});

package/tests/strArrayToDict-spec.ts

@@ -1,40 +0,0 @@
-import { describe, it } from "vitest";
-
-import { literal, strArrayToDict } from "../src/runtime";
-import type { Expect, Equal, ExpectFalse } from "@type-challenges/utils";
-
-describe("strArrayToDict() utility", () => {
-  it("", () => {
-    const result = strArrayToDict("a", "b", "c");
-    type R = typeof result;
-
-    const start = ["a", "b", "c"] as const;
-    const result2 = strArrayToDict(...start);
-    type R2 = typeof result2;
-
-    const start3 = literal(["a", "b", "c"]);
-    const result3 = strArrayToDict(...start3);
-    type R3 = typeof result3;
-
-    const start4 = ["a", "b", "c"];
-    const result4 = strArrayToDict(...start4);
-    type R4 = typeof result4;
-
-    type cases = [
-      // as long as we ensure that the array consists of literals
-      // we are good for the conversion
-      Expect<Equal<R, { a: true; b: true; c: true }>>,
-      Expect<Equal<R2, { a: true; b: true; c: true }>>,
-      Expect<Equal<R3, { a: true; b: true; c: true }>>,
-      // but a non-literal array doesn't work
-      // TODO: see if there's a way to force input to be literal
-      ExpectFalse<Equal<R4, { a: true; b: true; c: true }>>,
-      // and unfortunately it's lost all track of the keys
-      // which are involved; just knowning that they are
-      // string based keys
-      Expect<Equal<keyof R4, string>>
-    ];
-
-    const cases: cases = [true, true, true, false, true];
-  });
-});

package/tests/tuples/TupleToUnion.spec.ts

@@ -1,20 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { TupleToUnion } from "src/types";
-import { Expect, Equal } from "@type-challenges/utils";
-
-describe("TupleToUnion<T> type utility", () => {
-  it("an array of literals is converted ot a tuple", () => {
-    const arr = [1, 2, 5] as const;
-    type Arr = typeof arr;
-    type Union = TupleToUnion<Arr>;
-
-    type cases = [
-      //
-      Expect<Equal<Union, 1 | 2 | 5>>
-    ];
-
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-});