inferred-types 0.33.4 → 0.34.2

package/src/types/{type-checks → boolean-logic}/index.ts

@@ -1,8 +1,7 @@
+export * from "./array";
 export * from "./Includes";
-export * from "./IsBooleanLiteral";
-export * from "./IsNumericLiteral";
+export * from "./boolean";
 export * from "./IsScalar";
-export * from "./IsStringLiteral";
 export * from "./IsLiteral";
 export * from "./IsUndefined";
 export * from "./Extends";
@@ -10,3 +9,5 @@ export * from "./TypeDefault";
 export * from "./object";
 export * from "./StartsWith";
 export * from "./EndsWith";
+export * from "./Or";
+export * from "./equivalency";

package/src/types/{type-checks → boolean-logic}/object.ts

@@ -1,5 +1,6 @@
 import { FunctionType } from "../FunctionType";
 import { Mutable } from "../Mutable";
+import { Narrowable } from "../Narrowable";
 
 /**
  * **IsObject**
@@ -24,4 +25,6 @@ export type IsObject<T> = Mutable<T> extends Record<string, any>
  * Branch type utility with return `IF` when `T` extends an object type
  * and `ELSE` otherwise
  */
-export type IfObject<T, IF, ELSE> = IsObject<T> extends true ? IF : ELSE;
+export type IfObject<T, IF extends Narrowable, ELSE extends Narrowable> = IsObject<T> extends true
+  ? IF
+  : ELSE;

package/src/types/{type-checks → boolean-logic}/string.ts

@@ -18,4 +18,4 @@ export type IfString<
   T extends Narrowable, //
   IF extends Narrowable,
   ELSE extends Narrowable
-> = IsString<T> extends true ? IF : ELSE;
+> = IsString<T> extends true ? IF : IsString<T> extends false ? ELSE : IF | ELSE;

package/src/types/dictionary/MapTo.ts

@@ -6,7 +6,7 @@ import {
   DefaultOneToOneMapping,
 } from "src/runtime/dictionary/mapTo";
 import { EnumValues } from "../EnumValues";
-import { TypeDefault } from "../type-checks/TypeDefault";
+import { TypeDefault } from "../boolean-logic/TypeDefault";
 
 /**
  * Expresses relationship between inputs/outputs:

package/src/types/functions/LogicFunction.ts

@@ -1,4 +1,4 @@
 /**
  * A function which returns a boolean value
  */
-export type LogicFunction<T extends any[]> = (...args: T) => boolean;
+export type LogicFunction<T extends readonly any[]> = (...args: T) => boolean;

package/src/types/index.ts

@@ -41,7 +41,7 @@ export * from "./literal-unions/index";
 export * from "./string-literals/index";
 export * from "./tuples/index";
 export * from "./type-conversion/index";
-export * from "./type-checks/index";
+export * from "./boolean-logic/index";
 
 // #endregion auto-indexed files
 

package/src/types/lists/FilterTuple.ts

@@ -0,0 +1,20 @@
+/**
+ * **FilterTuple**
+ *
+ * Allows a known tuple `T` to be _filtered down_ by eliminating all items
+ * in the Tuple that _extend_ type `F`
+ * ```ts
+ * type T = [1,"foo",3];
+ * // [1,3]
+ * type T2 = FilterTuple<T, string>;
+ * ```
+ */
+export type FilterTuple<
+  TTuple extends any[] | readonly any[],
+  TFilter,
+  Result extends any[] = []
+> = TTuple extends [infer A, ...infer R]
+  ? [A] extends [TFilter]
+    ? FilterTuple<R, TFilter, Result>
+    : FilterTuple<R, TFilter, [...Result, A]>
+  : Result;

package/src/types/lists/index.ts

@@ -8,6 +8,7 @@
 export * from "./AfterFirst";
 export * from "./First";
 export * from "./FirstString";
+export * from "./FilterTuple";
 export * from "./Split";
 export * from "./UniqueForProp";
 

package/tests/boolean-logic/Contains.test.ts

@@ -0,0 +1,55 @@
+import { Equal, Expect } from "@type-challenges/utils";
+import { Contains, NarrowlyContains } from "src/types/boolean-logic/array";
+import { describe, it } from "vitest";
+
+describe("Contains<T,A>", () => {
+  it("happy-path", () => {
+    type T1 = [number, 32, 64, "foo"];
+    type T2 = [false, true];
+    type T3 = [42, 64, 128];
+    type T4 = ["foo", "bar"];
+
+    type cases = [
+      // "foo" extends string so true
+      Expect<Equal<Contains<string, T1>, true>>,
+      // "bar" does NOT extend "foo"
+      Expect<Equal<Contains<"bar", T1>, false>>,
+      // T4 has literal string but this will match the wide type string
+      Expect<Equal<Contains<string, T4>, true>>,
+      // T1 has both wide and narrow versions of "number"
+      Expect<Equal<Contains<number, T1>, true>>,
+      // T3 has narrow versions of "number"
+      Expect<Equal<Contains<number, T3>, true>>,
+      // boolean literals evaluate to wide type
+      Expect<Equal<Contains<boolean, T2>, true>>
+    ];
+    const cases: cases = [true, true, true, true, true, true];
+  });
+});
+
+describe("NarrowlyContains<T,A>", () => {
+  it("happy-path", () => {
+    type T1 = [number, 32, 64, "foo"];
+    type T2 = [false, true];
+    type T3 = [42, 64, 128];
+    type T4 = ["foo", "bar"];
+
+    type cases = [
+      // "foo" is not equal to string
+      Expect<Equal<NarrowlyContains<string, T1>, false>>,
+      // "foo" does equal "foo"
+      Expect<Equal<NarrowlyContains<"foo", T1>, true>>,
+      // T4 has literal string but this doesn't match with NarrowlyContains
+      Expect<Equal<NarrowlyContains<string, T4>, false>>,
+      // T1 has both wide and narrow versions of "number" but match is only on wide type
+      Expect<Equal<NarrowlyContains<number, T1>, true>>,
+      // T3 has matches on narrow number
+      Expect<Equal<NarrowlyContains<42, T3>, true>>,
+      // T3 identifies a non-match of narrow numbers
+      Expect<Equal<NarrowlyContains<442, T3>, false>>,
+      // boolean literals evaluate to wide type
+      Expect<Equal<NarrowlyContains<boolean, T2>, false>>
+    ];
+    const cases: cases = [true, true, true, true, true, true, true];
+  });
+});

package/tests/dictionary/TypeDefault.test.ts

@@ -1,6 +1,6 @@
 import { describe, it } from "vitest";
 import { Equal, Expect } from "@type-challenges/utils";
-import { TypeDefault } from "src/types/type-checks/TypeDefault";
+import { TypeDefault } from "src/types/boolean-logic/TypeDefault";
 import { literal } from "src/runtime/literals";
 
 describe("TypeDefault<T,D>", () => {

package/tests/lists/Length.test.ts

@@ -0,0 +1,19 @@
+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/runtime/if-is.spec.ts

@@ -2,6 +2,8 @@ import { describe, expect, it } from "vitest";
 
 import type { Expect, Equal } from "@type-challenges/utils";
 import {
+  ifArray,
+  ifArrayPartial,
   ifBoolean,
   ifNumber,
   ifString,
@@ -9,9 +11,10 @@ import {
   ifUndefined,
   isTrue,
 } from "src/runtime/type-checks";
-import { EndsWith, StartsWith } from "src/types";
+import { EndsWith, Extends, LowerAlpha, Or, StartsWith } from "src/types";
 import { ifStartsWith, startsWith } from "src/runtime/type-checks/startsWith";
 import { box } from "src/runtime/literals";
+import { or } from "src/runtime";
 
 describe("runtime if/is", () => {
   it("ifString(v,i,e)", () => {
@@ -55,7 +58,7 @@ describe("runtime if/is", () => {
     type cases = [
       Expect<Equal<typeof t, 42>>, //
       Expect<Equal<typeof f, 42>>, //
-      Expect<Equal<typeof f2, 42>> //
+      Expect<Equal<typeof f2, "yikes" | 42>> //
     ];
     const cases: cases = [true, true, true];
   });
@@ -115,6 +118,104 @@ describe("runtime if/is", () => {
     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);
@@ -135,14 +236,21 @@ describe("runtime if/is", () => {
     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>>
+      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];
+    const cases: cases = [true, true, true, true, true, true, true];
   });
 
   it("EndsWith<T,U>", () => {
@@ -187,7 +295,7 @@ describe("runtime if/is", () => {
       // condition
       "foo",
       // inline
-      (i) => `welcome ${i}` as const,
+      (i) => `welcome ${i}`,
       // external
       noSir
     );

package/src/types/type-checks/EndsWith.ts

@@ -1,22 +0,0 @@
-import { IfStringLiteral } from "src/types/type-checks";
-
-/**
- * **EndsWith**<T,U>
- *
- * A type utility which checks whether `T` _ends with_ the string literal `U`.
- *
- * If both `T` and `U` are string literals then the type system will resolve
- * to a literal `true` or `false` but if either is not a literal that it will
- * just resolve to `boolean` as the value can not be known at design time..
- */
-export type EndsWith<T extends unknown, U extends unknown> = T extends string
-  ? U extends string
-    ? T extends `${string}${U}`
-      ? IfStringLiteral<
-          T, //
-          IfStringLiteral<U, true, boolean>,
-          boolean
-        >
-      : IfStringLiteral<T, false, boolean>
-    : false
-  : false;

package/src/types/type-checks/Extends.ts

@@ -1,14 +0,0 @@
-/**
- * **Extends**
- *
- * Boolean type utility which returns `true` if `E` _extends_ `T`.
- */
-export type Extends<E, T> = E extends T ? true : false;
-
-/**
- * **IfExtends**
- *
- * Branching type utility which returns type `IF` when `E` _extends_ `T`; otherwise
- * it will return the type `ELSE`.
- */
-export type IfExtends<E, T, IF, ELSE> = Extends<E, T> extends true ? IF : ELSE;

package/src/types/type-checks/IsBooleanLiteral.ts

@@ -1,16 +0,0 @@
-/**
- * **IsBooleanLiteral**
- *
- * Type utility which returns true/false if the boolean value is a _boolean literal_ versus
- * just the wider _boolean_ type.
- */
-export type IsBooleanLiteral<T extends boolean> = boolean extends T ? false : true;
-
-/**
- * **IfBooleanLiteral**
- *
- * Branch utility which returns `IF` type when `T` is a boolean literal and `ELSE` otherwise
- */
-export type IfBooleanLiteral<T extends boolean, IF, ELSE> = IsBooleanLiteral<T> extends true
-  ? IF
-  : ELSE;

package/src/types/type-checks/IsNumericLiteral.ts

@@ -1,16 +0,0 @@
-/**
- * **IsNumericLiteral**
- *
- * Type utility which returns true/false if the numeric value a _numeric literal_ versus
- * just the _number_ type.
- */
-export type IsNumericLiteral<T extends number> = number extends T ? false : true;
-
-/**
- * **IfNumericLiteral**
- *
- * Branch utility which returns `IF` type when `T` is a numeric literal and `ELSE` otherwise
- */
-export type IfNumericLiteral<T extends number, IF, ELSE> = IsNumericLiteral<T> extends true
-  ? IF
-  : ELSE;

package/src/types/type-checks/IsScalar.ts

@@ -1,14 +0,0 @@
-export type IsScalar<T> = [T] extends [string]
-  ? true
-  : [T] extends [number]
-  ? true
-  : [T] extends [boolean]
-  ? true
-  : false;
-
-/**
- * **IfScalar**
- *
- * Branch type utility which returns `IF` when `T` is a scalar value and `ELSE` otherwise
- */
-export type IfScalar<T, IF, ELSE> = IsScalar<T> extends true ? IF : ELSE;

package/src/types/type-checks/IsStringLiteral.ts

@@ -1,14 +0,0 @@
-/**
- * **IsStringLiteral**
- *
- * Type utility which returns true/false if the string a _string literal_ versus
- * just the _string_ type.
- */
-export type IsStringLiteral<T> = [T] extends [string] ? (string extends T ? false : true) : false;
-
-/**
- * **IfStringLiteral**
- *
- * Branch utility which returns `IF` type when `T` is a string literal and `ELSE` otherwise
- */
-export type IfStringLiteral<T, IF, ELSE> = [IsStringLiteral<T>] extends [true] ? IF : ELSE;