inferred-types 0.33.4 → 0.34.0

package/.vscode/settings.json

@@ -9,6 +9,7 @@
     "Dasherize",
     "dasherized",
     "Decomp",
+    "foey",
     "foofoo",
     "fooy",
     "ruleset",

package/dist/index.d.ts

@@ -141,6 +141,97 @@ type Keys<T extends Record<string, any> | readonly string[], W extends string |
  */
 type Length<T extends readonly any[]> = T["length"];
 
+/**
+ * **Equal**`<X,Y>`
+ *
+ * Type utility which tests whether two types -- `X` and `Y` -- are exactly the same type
+ */
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+/**
+ * **NotEqual**`<X,Y>`
+ *
+ * Type utility which tests whether two types -- `X` and `Y` -- are _not_ exactly the same type
+ */
+type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
+
+/**
+ * **AfterFirst**`<T>`
+ *
+ * returns the elements in an array _after_ the first element
+ */
+type AfterFirst<T extends readonly any[]> = T extends readonly [any, ...any[]] ? T extends readonly [any, ...infer Rest] ? Rest : never : T;
+
+/**
+ * returns the first `string` value from an array of values
+ */
+type FirstString<T> = T extends [infer S extends string, ...unknown[]] ? S : never;
+
+/**
+ * **Split**`<T, SEP>`
+ *
+ * Splits a string literal `T` by string literal _separator_ `SEP`. The result is an array
+ * of string literals.
+ */
+type Split<T extends string, SEP extends string, ANSWER extends string[] = []> = string extends T ? string[] : T extends SEP ? ANSWER : T extends `${infer HEAD}${SEP}${infer TAIL}` ? Split<TAIL, SEP, [...ANSWER, HEAD]> : [...ANSWER, T];
+
+/**
+ * Get the type of a property of an object:
+ * ```ts
+ * const car = { make: "Chevy", model: "Malibu", }
+ * ```
+ */
+type Get<T, K> = K extends `${infer FK}.${infer L}` ? FK extends keyof T ? Get<T[FK], L> : never : K extends keyof T ? T[K] : never;
+
+/**
+ * A union of types used in conjunction with the `literalValues()` function
+ * to produce a _narrow_ type definition of a passed in dictionary object.
+ */
+type Narrowable = string | number | boolean | symbol | object | undefined | void | null | {};
+
+/**
+ * Create a union type based on a given property in an array of objects
+ * ```ts
+ * const data = [
+ *    { id: 123, color: "blue" },
+ *    { id: 456, color: "red" },
+ *  ] as const;
+ * // 123 | 456
+ * type U = UniqueForProp<typeof data, "id">;
+ * ```
+ */
+type UniqueForProp<T extends readonly Record<string, Narrowable>[], P extends string> = Readonly<Get<T[number], P>>;
+
+type IsArray<T> = [T] extends [any[]] ? true : [T] extends [readonly any[]] ? true : false;
+type IsReadonlyArray<T> = T extends readonly any[] ? true : false;
+/**
+ * **IfArray**`<T, IF, ELSE>`
+ *
+ * Type utility which convert to type `IF` or `ELSE` based on whether `T` is an array
+ */
+type IfArray<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable> = IsArray<T> extends true ? IF : ELSE;
+/**
+ * **IfArray**`<T, IF, ELSE>`
+ *
+ * Type utility which convert to type `IF` or `ELSE` based on whether `T` is a readonly array
+ */
+type IfReadonlyArray<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable> = IsReadonlyArray<T> extends true ? IF : ELSE;
+/**
+ * **Contains**`<T, A>`
+ *
+ * Type utility which checks whether a type `T` exists within an array `A`. Result is
+ * `true` if `T` _extends_ any element in `A` making it match widely against `A`. If you
+ * prefer a narrower match you can use `NarrowlyContains<T,A>` instead.
+ */
+type Contains<T extends Narrowable, A extends readonly any[]> = First<A> extends T ? true : [] extends AfterFirst<A> ? false : Contains<T, AfterFirst<A>>;
+/**
+ * **NarrowlyContains**`<T, A>`
+ *
+ * Type utility which checks whether a type `T` exists within an array `A`. Result is
+ * `true` if `T` _extends_ any element in `A` making it match widely against `A`. If you
+ * prefer a wider match you can use `Contains<T,A>` instead.
+ */
+type NarrowlyContains<T extends Narrowable, A extends readonly any[]> = Equal<First<A>, T> extends true ? true : [] extends AfterFirst<A> ? false : NarrowlyContains<T, AfterFirst<A>>;
+
 /**
  * Converts a Tuple type into a _union_ of the tuple elements
  * ```ts
@@ -168,6 +259,34 @@ type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never] ? [] : [...Uni
 
 type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
 
+type IsBoolean<T> = T extends boolean ? true : false;
+/**
+ * Type utility which returns `true` or `false` based on
+ * whether the type holds the narrow "true" type.
+ * ```ts
+ * // true
+ * type T = IsTrue<true>;
+ * // boolean
+ * type U = IsTrue<boolean>;
+ * // false
+ * type F = IsTrue<false>;
+ * type F2 = IsTrue<"false">;
+ * ```
+ */
+type IsTrue<T extends Narrowable> = IsBoolean<T> extends true ? T extends true ? true : T extends false ? false : unknown : false;
+type IsFalse<T extends Narrowable> = IsBoolean<T> extends true ? T extends false ? true : true extends T ? false : unknown : false;
+/**
+ * Type utility which checks for literal `true` value and then switches type
+ * to the IF, ELSE, or MAYBE generic types passed in where _maybe_ is when T
+ * is the wide type of `boolean`
+ */
+type IfTrue<T, IF, ELSE, MAYBE> = IsTrue<T> extends true ? IF : IsTrue<T> extends false ? ELSE : MAYBE;
+/**
+ * Type utility which checks for literal `false` value and then switches type
+ * to the IF, ELSE, or MAYBE generic types passed in where _maybe_ is when T
+ * is the wide type of `boolean`
+ */
+type IfFalse<T, IF, ELSE, MAYBE> = IsFalse<T> extends true ? IF : IsTrue<T> extends false ? ELSE : MAYBE;
 /**
  * **IsBooleanLiteral**
  *
@@ -264,12 +383,6 @@ type IsScalar<T> = [T] extends [string] ? true : [T] extends [number] ? true : [
  */
 type IfScalar<T, IF, ELSE> = IsScalar<T> extends true ? IF : ELSE;
 
-/**
- * A union of types used in conjunction with the `literalValues()` function
- * to produce a _narrow_ type definition of a passed in dictionary object.
- */
-type Narrowable = string | number | boolean | symbol | object | undefined | void | null | {};
-
 /**
  * **IsUndefined**
  *
@@ -285,11 +398,11 @@ type IsUndefined<T extends Narrowable> = T extends undefined ? true : false;
 type IfUndefined<T, IF, ELSE> = IsUndefined<T> extends true ? IF : ELSE;
 
 /**
- * **Extends**
+ * **Extends**`<T, EXTENDS>`
  *
- * Boolean type utility which returns `true` if `E` _extends_ `T`.
+ * Boolean type utility which returns `true` if `T` _extends_ `EXTENDS`.
  */
-type Extends<E, T> = E extends T ? true : false;
+type Extends<T, EXTENDS> = T extends EXTENDS ? true : false;
 /**
  * **IfExtends**
  *
@@ -1212,14 +1325,6 @@ O extends (...args: any[]) => any = (...args: any[]) => any> = SimplifyObject<{
     [K in keyof T]: T[K] extends O ? T[K] extends (...args: infer A) => any ? Record<K, (...args: A) => R> : Record<K, T[K]> : Record<K, T[K]>;
 }[keyof T]>;
 
-/**
- * Get the type of a property of an object:
- * ```ts
- * const car = { make: "Chevy", model: "Malibu", }
- * ```
- */
-type Get<T, K> = K extends `${infer FK}.${infer L}` ? FK extends keyof T ? Get<T[FK], L> : never : K extends keyof T ? T[K] : never;
-
 /**
  * Expresses whether an option is "opt" (optional) or "req" (required)
  */
@@ -1544,7 +1649,7 @@ type FinalReturn<T extends any> = T extends (...args: any[]) => any ? FinalRetur
 /**
  * A function which returns a boolean value
  */
-type LogicFunction<T extends any[]> = (...args: T) => boolean;
+type LogicFunction<T extends readonly any[]> = (...args: T) => boolean;
 
 type DictFromKv<T extends readonly {
     key: string;
@@ -1594,37 +1699,11 @@ type KvFrom<T extends object> = Array<{
 type KvTuple<T, K extends keyof T> = [K, Record<K, T[K]>];
 
 /**
- * **AfterFirst**`<T>`
+ * **Or**`<T>`
  *
- * returns the elements in an array _after_ the first element
+ * Takes an array of boolean values and produces a boolean OR across these values
  */
-type AfterFirst<T extends readonly any[]> = T extends readonly [any, ...any[]] ? T extends readonly [any, ...infer Rest] ? Rest : never : T;
-
-/**
- * returns the first `string` value from an array of values
- */
-type FirstString<T> = T extends [infer S extends string, ...unknown[]] ? S : never;
-
-/**
- * **Split**`<T, SEP>`
- *
- * Splits a string literal `T` by string literal _separator_ `SEP`. The result is an array
- * of string literals.
- */
-type Split<T extends string, SEP extends string, ANSWER extends string[] = []> = string extends T ? string[] : T extends SEP ? ANSWER : T extends `${infer HEAD}${SEP}${infer TAIL}` ? Split<TAIL, SEP, [...ANSWER, HEAD]> : [...ANSWER, T];
-
-/**
- * Create a union type based on a given property in an array of objects
- * ```ts
- * const data = [
- *    { id: 123, color: "blue" },
- *    { id: 456, color: "red" },
- *  ] as const;
- * // 123 | 456
- * type U = UniqueForProp<typeof data, "id">;
- * ```
- */
-type UniqueForProp<T extends readonly Record<string, Narrowable>[], P extends string> = Readonly<Get<T[number], P>>;
+type Or<T extends readonly boolean[]> = NarrowlyContains<true, T> extends true ? true : NarrowlyContains<boolean, T> extends true ? boolean : false;
 
 type DictArrayFilterCallback<K extends keyof T, T extends object, R extends true | false> = (key: K, value: Pick<T, K>) => R;
 /**
@@ -1738,13 +1817,7 @@ declare const api: <N extends Narrowable, TPrivate extends Readonly<Record<any,
  */
 declare const and: <T extends any[]>(...ops: readonly LogicFunction<T>[]) => LogicFunction<T>;
 
-/**
- * Groups a number of "logic functions" together by combining their results using
- * the logical **OR** operator.
- *
- * **Note:** a "logic function" is any function which returns a boolean
- */
-declare const or: <T extends any[]>(...ops: LogicFunction<T>[]) => LogicFunction<T>;
+declare function or<O extends readonly boolean[]>(...conditions: O): Or<O>;
 
 /**
  * Groups a number of "logic functions" together by combining their results using
@@ -2165,10 +2238,15 @@ type SuggestNumeric<T extends number> = T | (number & {});
 type Condition<TInput extends Narrowable, TResult extends boolean> = (input: TInput) => TResult;
 declare const condition: <TInput extends Narrowable, C extends Condition<Narrowable, boolean>>(c: C, input: TInput) => boolean;
 
-type IsArray<T> = T extends any[] ? true : false;
 declare function isArray<T>(i: T): IsArray<T>;
+/**
+ * **ifArray**(T, IF, ELSE)
+ *
+ * A utility which evaluates a type `T` for whether it is an array and then
+ */
+declare function ifArray<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(val: T, isAnArray: <N extends T & readonly any[]>(arr: N) => IF, isNotAnArray: <N extends Exclude<T, any[]>>(nonArr: N) => ELSE): IfArray<T, IF, ELSE>;
+declare function ifArrayPartial<T extends Narrowable>(): <IF extends Narrowable, ELSE extends Narrowable>(isAnArray: <N extends T & readonly any[]>(arr: N) => IF, isNotAnArray: <N_1 extends Exclude<T, any[]>>(nonArr: N_1) => ELSE) => <V extends T>(val: V) => IfArray<V, IF, ELSE>;
 
-type IsBoolean<T> = T extends boolean ? true : false;
 /**
  * Runtime and type checks whether a variable is a boolean value.
  */
@@ -2186,8 +2264,23 @@ declare function isBoolean<T extends any>(i: T): IsBoolean<T>;
  */
 declare function ifBoolean<T, IF, ELSE>(val: T, ifVal: IF, elseVal: ELSE): IsBoolean<T> extends true ? IF : ELSE;
 
-type IsFalse<T extends Narrowable> = IsBoolean<T> extends true ? T extends false ? true : true extends T ? false : unknown : false;
 declare function isFalse<T>(i: T): IsFalse<T>;
+/**
+ * **ifTrue**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * a _true_ and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested
+ * @param ifVal the value (strongly typed) returned if val is _true_ value
+ * @param elseVal the value (strongly typed) returned if val is NOT a _true_ value
+ *
+ * Note: at runtime there's no way to distinguish if the value was widely or loosely
+ * typed so unlike the type utility there is no "MAYBE" state but if a wide type if
+ * encountered the _type_ will the union of `IF` and `ELSE`.
+ */
+declare function ifFalse<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(val: T, ifVal: IF, elseVal: ELSE): IfFalse<T, IF, ELSE, IF | ELSE>;
 
 type IsFunction<T> = T extends FunctionType ? true : false;
 type HybridFunction<TProps extends {}> = (<TArgs extends any[]>(...args: TArgs) => any) & TProps;
@@ -2287,20 +2380,6 @@ declare function ifString<T extends Narrowable, IF extends Narrowable, ELSE exte
 
 declare function isSymbol<T>(i: T): T extends symbol ? true : false;
 
-/**
- * Type utility which returns `true` or `false` based on
- * whether the type holds the narrow "true" type.
- * ```ts
- * // true
- * type T = IsTrue<true>;
- * // unknown
- * type U = IsTrue<boolean>;
- * // false
- * type F = IsTrue<false>;
- * type F2 = IsTrue<"false">;
- * ```
- */
-type IsTrue<T> = IsBoolean<T> extends true ? T extends true ? true : T extends false ? false : unknown : false;
 /**
  * Run-time and type checking of whether a variable is `true`.
  */
@@ -2315,8 +2394,12 @@ declare function isTrue<T extends Narrowable>(i: T): IsTrue<T>;
  * @param val the value being tested
  * @param ifVal the value (strongly typed) returned if val is _true_ value
  * @param elseVal the value (strongly typed) returned if val is NOT a _true_ value
+ *
+ * Note: at runtime there's no way to distinguish if the value was widely or loosely
+ * typed so unlike the type utility there is no "MAYBE" state but if a wide type if
+ * encountered the _type_ will the union of `IF` and `ELSE`.
  */
-declare function ifTrue<T extends Narrowable, IF, ELSE>(val: T, ifVal: IF, elseVal: ELSE): IsTrue<T> extends true ? IF : ELSE;
+declare function ifTrue<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(val: T, ifVal: IF, elseVal: ELSE): IfTrue<T, IF, ELSE, IF | ELSE>;
 
 declare function isUndefined<T extends Narrowable>(i: T): undefined extends T ? true : false;
 /**
@@ -2440,4 +2523,4 @@ interface IFluentConfigurator<C> {
  */
 declare function FluentConfigurator<I>(initial?: I): IFluentConfigurator<{}>;
 
-export { AfterFirst, AllCaps, Alpha, AlphaNumeric, AnyFunction, Api, ApiFunction, ApiValue, AppendToDictionary, AppendToObject, ArrConcat, Array$1 as Array, ArrayConverter, AsArray, AsFinalizedConfig, AssertExtends, Box, BoxValue, BoxedFnParams, BoxedReturn, Bracket, Break, CamelCase, CapitalizeWords, Cardinality, Cardinality0, Cardinality1, CardinalityExplicit, CardinalityFilter0, CardinalityFilter1, CardinalityIn, CardinalityInput, CardinalityNode, CardinalityOut, CardinalityTuple, ClosingBracket, Condition, ConditionFilter, Configurator, ConfiguredMap, Constructor, DEFAULT_MANY_TO_ONE_MAPPING, DEFAULT_ONE_TO_MANY_MAPPING, DEFAULT_ONE_TO_ONE_MAPPING, DashToSnake, DashUppercase, Dasherize, DecomposeMapConfig, DefaultManyToOneMapping, DefaultOneToManyMapping, DefaultOneToOneMapping, DefinePropertiesApi, DictArrApi, DictArray, DictArrayFilterCallback, DictArrayKv, DictChangeValue, DictFromKv, DictKvTuple, DictPartialApplication, DictPrependWithFn, DictReturnValues, DomainName, DynamicRule, DynamicRuleSet, Email, EndsWith, EnumValues, ExpandRecursively, ExpectExtends, ExplicitFunction, Extends, FilterContains, FilterDefn, FilterEnds, FilterEquals, FilterFn, FilterGreaterThan, FilterIs, FilterLessThan, FilterNotEqual, FilterStarts, FinalReturn, FinalizedMapConfig, First, FirstKey, FirstKeyValue, FirstOfEach, FirstOrUndefined, FirstString, FluentConfigurator, FluentFunction, FnShape, FromDictArray, FullyQualifiedUrl, FunctionType, GeneralDictionary, Get, HasUppercase, HybridFunction, IConfigurator, IFluentConfigurator, If, IfBooleanLiteral, IfExtends, IfExtendsThen, IfLiteral, IfNumericLiteral, IfObject, IfOptionalLiteral, IfScalar, IfStartsWith, IfStringLiteral, IfUndefined, Include, Includes, IntersectingKeys, Ipv4, IsArray, IsBoolean, IsBooleanLiteral, IsCapitalized, IsFalse, IsFunction, IsLiteral, IsNull, IsNumber, IsNumericLiteral, IsObject, IsOptionalLiteral, IsScalar, IsStringLiteral, IsTrue, IsUndefined, KebabCase, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LogicFunction, LogicalCombinator, LowerAllCaps, LowerAlpha, ManyToMany, ManyToOne, ManyToZero, MapCard, MapCardinality, MapCardinalityFrom, MapCardinalityIllustrated, MapConfig, MapFn, MapFnInput, MapFnOutput, MapIR, MapInput, MapInputFrom, MapOR, MapOutput, MapOutputFrom, MapTo, Mapper, MapperApi, MaybeFalse, MaybeTrue, Mutable, MutableProps, NarrowBox, Narrowable, NetworkProtocol, NonAlpha, NonNumericKeys, NonStringKeys, Not, NotFilter, Numeric, NumericFilter, NumericKeys, NumericString, ObjectType, OneToMany, OneToOne, OneToZero, Opaque, OpeningBracket, OptRequired, OptionalKeys, OptionalProps, Parenthesis, PascalCase, Pluralize, PrivateKey, PrivateKeys, PublicKeys, Punctuation, PureFluentApi, RelativeUrl, Replace, RequireProps, RequiredKeys, RequiredProps, Retain, RightWhitespace, RuleDefinition, RuntimeProp, RuntimeType, SameKeys, SecondOfEach, SimpleFunction, SimplifyObject, SnakeCase, SpecialCharacters, Split, StartsWith, StringDelimiter, StringFilter, StringKeys, StringLength, Suggest, SuggestNumeric, ToFluent, Transformer, Trim, TrimLeft, TrimRight, TupleToUnion, Type, TypeApi, TypeDefault, TypeDefinition, TypeGuard, TypeOptions, Unbox, UndefinedArrayIsUnknown, UndefinedTreatment, UndefinedValue, UnionToIntersection, UnionToTuple, UniqueDictionary, UniqueForProp, Uniqueness, UnwrapNot, UpperAlpha, UrlBuilder, VariableName, Where, WhereNot, Whitespace, Widen, WithNumericKeys, WithStringKeys, WithValue, ZeroToMany, ZeroToOne, ZeroToZero, ZipCode, and, api, arrayToKeyLookup, arrayToObject, asArray, box, condition, createFnWithProps, defineProperties, defineType, dictArr, dictToKv, dictionaryTransform, entries, filter, filterDictArray, fnWithProps, groupBy, idLiteral, idTypeGuard, identity, ifBoolean, ifNull, ifNumber, ifString, ifTrue, ifUndefined, isArray, isBoolean, isBox, isFalse, isFunction, isNotFilter, isNull, isNumber, isNumericFilter, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, literal, mapTo, mapToDict, mapToFn, mapValues, nameLiteral, not, or, readonlyFnWithProps, ruleSet, strArrayToDict, type, typeApi, unbox, withValue };
+export { AfterFirst, AllCaps, Alpha, AlphaNumeric, AnyFunction, Api, ApiFunction, ApiValue, AppendToDictionary, AppendToObject, ArrConcat, Array$1 as Array, ArrayConverter, AsArray, AsFinalizedConfig, AssertExtends, Box, BoxValue, BoxedFnParams, BoxedReturn, Bracket, Break, CamelCase, CapitalizeWords, Cardinality, Cardinality0, Cardinality1, CardinalityExplicit, CardinalityFilter0, CardinalityFilter1, CardinalityIn, CardinalityInput, CardinalityNode, CardinalityOut, CardinalityTuple, ClosingBracket, Condition, ConditionFilter, Configurator, ConfiguredMap, Constructor, Contains, DEFAULT_MANY_TO_ONE_MAPPING, DEFAULT_ONE_TO_MANY_MAPPING, DEFAULT_ONE_TO_ONE_MAPPING, DashToSnake, DashUppercase, Dasherize, DecomposeMapConfig, DefaultManyToOneMapping, DefaultOneToManyMapping, DefaultOneToOneMapping, DefinePropertiesApi, DictArrApi, DictArray, DictArrayFilterCallback, DictArrayKv, DictChangeValue, DictFromKv, DictKvTuple, DictPartialApplication, DictPrependWithFn, DictReturnValues, DomainName, DynamicRule, DynamicRuleSet, Email, EndsWith, EnumValues, Equal, ExpandRecursively, ExpectExtends, ExplicitFunction, Extends, FilterContains, FilterDefn, FilterEnds, FilterEquals, FilterFn, FilterGreaterThan, FilterIs, FilterLessThan, FilterNotEqual, FilterStarts, FinalReturn, FinalizedMapConfig, First, FirstKey, FirstKeyValue, FirstOfEach, FirstOrUndefined, FirstString, FluentConfigurator, FluentFunction, FnShape, FromDictArray, FullyQualifiedUrl, FunctionType, GeneralDictionary, Get, HasUppercase, HybridFunction, IConfigurator, IFluentConfigurator, If, IfArray, IfBooleanLiteral, IfExtends, IfExtendsThen, IfFalse, IfLiteral, IfNumericLiteral, IfObject, IfOptionalLiteral, IfReadonlyArray, IfScalar, IfStartsWith, IfStringLiteral, IfTrue, IfUndefined, Include, Includes, IntersectingKeys, Ipv4, IsArray, IsBoolean, IsBooleanLiteral, IsCapitalized, IsFalse, IsFunction, IsLiteral, IsNull, IsNumber, IsNumericLiteral, IsObject, IsOptionalLiteral, IsReadonlyArray, IsScalar, IsStringLiteral, IsTrue, IsUndefined, KebabCase, KeyValue, KeyedRecord, Keys, KeysWithValue, KvFrom, KvTuple, LastInUnion, LeftWhitespace, Length, LogicFunction, LogicalCombinator, LowerAllCaps, LowerAlpha, ManyToMany, ManyToOne, ManyToZero, MapCard, MapCardinality, MapCardinalityFrom, MapCardinalityIllustrated, MapConfig, MapFn, MapFnInput, MapFnOutput, MapIR, MapInput, MapInputFrom, MapOR, MapOutput, MapOutputFrom, MapTo, Mapper, MapperApi, MaybeFalse, MaybeTrue, Mutable, MutableProps, NarrowBox, Narrowable, NarrowlyContains, NetworkProtocol, NonAlpha, NonNumericKeys, NonStringKeys, Not, NotEqual, NotFilter, Numeric, NumericFilter, NumericKeys, NumericString, ObjectType, OneToMany, OneToOne, OneToZero, Opaque, OpeningBracket, OptRequired, OptionalKeys, OptionalProps, Or, Parenthesis, PascalCase, Pluralize, PrivateKey, PrivateKeys, PublicKeys, Punctuation, PureFluentApi, RelativeUrl, Replace, RequireProps, RequiredKeys, RequiredProps, Retain, RightWhitespace, RuleDefinition, RuntimeProp, RuntimeType, SameKeys, SecondOfEach, SimpleFunction, SimplifyObject, SnakeCase, SpecialCharacters, Split, StartsWith, StringDelimiter, StringFilter, StringKeys, StringLength, Suggest, SuggestNumeric, ToFluent, Transformer, Trim, TrimLeft, TrimRight, TupleToUnion, Type, TypeApi, TypeDefault, TypeDefinition, TypeGuard, TypeOptions, Unbox, UndefinedArrayIsUnknown, UndefinedTreatment, UndefinedValue, UnionToIntersection, UnionToTuple, UniqueDictionary, UniqueForProp, Uniqueness, UnwrapNot, UpperAlpha, UrlBuilder, VariableName, Where, WhereNot, Whitespace, Widen, WithNumericKeys, WithStringKeys, WithValue, ZeroToMany, ZeroToOne, ZeroToZero, ZipCode, and, api, arrayToKeyLookup, arrayToObject, asArray, box, condition, createFnWithProps, defineProperties, defineType, dictArr, dictToKv, dictionaryTransform, entries, filter, filterDictArray, fnWithProps, groupBy, idLiteral, idTypeGuard, identity, ifArray, ifArrayPartial, ifBoolean, ifFalse, ifNull, ifNumber, ifString, ifTrue, ifUndefined, isArray, isBoolean, isBox, isFalse, isFunction, isNotFilter, isNull, isNumber, isNumericFilter, isObject, isString, isSymbol, isTrue, isType, isUndefined, keys, kindLiteral, kv, kvToDict, literal, mapTo, mapToDict, mapToFn, mapValues, nameLiteral, not, or, readonlyFnWithProps, ruleSet, strArrayToDict, type, typeApi, unbox, withValue };

package/dist/index.js

@@ -48,7 +48,10 @@ __export(src_exports, {
   idLiteral: () => idLiteral,
   idTypeGuard: () => idTypeGuard,
   identity: () => identity,
+  ifArray: () => ifArray,
+  ifArrayPartial: () => ifArrayPartial,
   ifBoolean: () => ifBoolean,
+  ifFalse: () => ifFalse,
   ifNull: () => ifNull,
   ifNumber: () => ifNumber,
   ifString: () => ifString,
@@ -151,12 +154,9 @@ var and = (...ops) => {
 };
 
 // src/runtime/combinators/or.ts
-var or = (...ops) => {
-  const fn = (...args) => {
-    return [...ops].some((i) => i(...args));
-  };
-  return fn;
-};
+function or(...conditions) {
+  return conditions.some((v) => v === true) ? true : false;
+}
 
 // src/runtime/combinators/not.ts
 var not = (op) => {
@@ -175,6 +175,14 @@ var condition = (c, input) => {
 function isArray(i) {
   return Array.isArray(i) === true;
 }
+function ifArray(val, isAnArray, isNotAnArray) {
+  return isArray(val) ? isAnArray(val) : isNotAnArray(val);
+}
+function ifArrayPartial() {
+  return (isAnArray, isNotAnArray) => {
+    return (val) => ifArray(val, isAnArray, isNotAnArray);
+  };
+}
 
 // src/runtime/type-checks/isBoolean.ts
 function isBoolean(i) {
@@ -188,6 +196,9 @@ function ifBoolean(val, ifVal, elseVal) {
 function isFalse(i) {
   return typeof i === "boolean" && !i;
 }
+function ifFalse(val, ifVal, elseVal) {
+  return isFalse(val) ? ifVal : elseVal;
+}
 
 // src/runtime/type-checks/isFunction.ts
 function isFunction(input) {
@@ -795,7 +806,10 @@ function literal(obj) {
   idLiteral,
   idTypeGuard,
   identity,
+  ifArray,
+  ifArrayPartial,
   ifBoolean,
+  ifFalse,
   ifNull,
   ifNumber,
   ifString,

package/dist/index.mjs

@@ -58,12 +58,9 @@ var and = (...ops) => {
 };
 
 // src/runtime/combinators/or.ts
-var or = (...ops) => {
-  const fn = (...args) => {
-    return [...ops].some((i) => i(...args));
-  };
-  return fn;
-};
+function or(...conditions) {
+  return conditions.some((v) => v === true) ? true : false;
+}
 
 // src/runtime/combinators/not.ts
 var not = (op) => {
@@ -82,6 +79,14 @@ var condition = (c, input) => {
 function isArray(i) {
   return Array.isArray(i) === true;
 }
+function ifArray(val, isAnArray, isNotAnArray) {
+  return isArray(val) ? isAnArray(val) : isNotAnArray(val);
+}
+function ifArrayPartial() {
+  return (isAnArray, isNotAnArray) => {
+    return (val) => ifArray(val, isAnArray, isNotAnArray);
+  };
+}
 
 // src/runtime/type-checks/isBoolean.ts
 function isBoolean(i) {
@@ -95,6 +100,9 @@ function ifBoolean(val, ifVal, elseVal) {
 function isFalse(i) {
   return typeof i === "boolean" && !i;
 }
+function ifFalse(val, ifVal, elseVal) {
+  return isFalse(val) ? ifVal : elseVal;
+}
 
 // src/runtime/type-checks/isFunction.ts
 function isFunction(input) {
@@ -701,7 +709,10 @@ export {
   idLiteral,
   idTypeGuard,
   identity,
+  ifArray,
+  ifArrayPartial,
   ifBoolean,
+  ifFalse,
   ifNull,
   ifNumber,
   ifString,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inferred-types",
-  "version": "0.33.4",
+  "version": "0.34.0",
   "description": "Functions which provide useful type inference on TS projects",
   "license": "MIT",
   "author": "Ken Snyder<ken@ken.net>",
@@ -22,11 +22,11 @@
     "watch:bundle": "npx tsup src/index.ts --dts --format=esm,cjs --watch",
     "clean": "rimraf dist/**/*",
     "lint": "eslint src/**/*.ts --fix && tsc --noEmit ",
-    "lint:full": "eslint src/**/*.ts && eslint test/**/*.ts && tsc --noEmit",
+    "lint:full": "eslint src/**/*.ts && eslint tests/**/*.ts && tsc --noEmit",
     "test": "vitest",
     "test:ci": "vitest run",
     "audit:fix": "pnpm audit --fix",
-    "release": "run-s lint release:latest test:ci audit:fix release:bump",
+    "release": "run-s lint:full release:latest test:ci audit:fix release:bump",
     "release:latest": "pnpm install",
     "release:bump": "bumpp"
   },

package/src/runtime/combinators/or.ts

@@ -1,15 +1,5 @@
-import { LogicFunction } from "src/types/functions";
+import { Or } from "src/types/combinators/Or";
 
-/**
- * Groups a number of "logic functions" together by combining their results using
- * the logical **OR** operator.
- *
- * **Note:** a "logic function" is any function which returns a boolean
- */
-export const or = <T extends any[]>(...ops: LogicFunction<T>[]): LogicFunction<T> => {
-  const fn: LogicFunction<T> = (...args: T) => {
-    return [...ops].some((i) => i(...args));
-  };
-
-  return fn;
-};
+export function or<O extends readonly boolean[]>(...conditions: O) {
+  return (conditions.some((v) => v === true) ? true : false) as Or<O>;
+}

package/src/runtime/type-checks/isArray.ts

@@ -1,5 +1,34 @@
-export type IsArray<T> = T extends any[] ? true : false;
+import { IsArray, IfArray } from "src/types/boolean-logic/array";
+import { Narrowable } from "src/types/Narrowable";
 
 export function isArray<T>(i: T) {
   return (Array.isArray(i) === true) as IsArray<T>;
 }
+
+/**
+ * **ifArray**(T, IF, ELSE)
+ *
+ * A utility which evaluates a type `T` for whether it is an array and then
+ */
+export function ifArray<
+  // value which is possibly an array
+  T extends Narrowable,
+  // functions which return a known type
+  IF extends Narrowable,
+  ELSE extends Narrowable
+>(
+  val: T,
+  isAnArray: <N extends T & readonly any[]>(arr: N) => IF,
+  isNotAnArray: <N extends Exclude<T, any[]>>(nonArr: N) => ELSE
+) {
+  return (isArray(val) ? isAnArray(val as any) : isNotAnArray(val as any)) as IfArray<T, IF, ELSE>;
+}
+
+export function ifArrayPartial<T extends Narrowable>() {
+  return <IF extends Narrowable, ELSE extends Narrowable>(
+    isAnArray: <N extends T & readonly any[]>(arr: N) => IF,
+    isNotAnArray: <N extends Exclude<T, any[]>>(nonArr: N) => ELSE
+  ) => {
+    return <V extends T>(val: V) => ifArray(val, isAnArray, isNotAnArray);
+  };
+}

package/src/runtime/type-checks/isBoolean.ts

@@ -1,4 +1,4 @@
-export type IsBoolean<T> = T extends boolean ? true : false;
+import { IsBoolean } from "src/types/boolean-logic";
 
 /**
  * Runtime and type checks whether a variable is a boolean value.

package/src/runtime/type-checks/isFalse.ts

@@ -1,17 +1,29 @@
+import { IfFalse, IsFalse } from "src/types/boolean-logic/boolean";
 import { Narrowable } from "src/types/Narrowable";
-import { IsBoolean } from "./isBoolean";
-
-export type IsFalse<T extends Narrowable> = IsBoolean<T> extends true
-  ? // is a boolean
-    T extends false
-    ? true
-    : true extends T
-    ? false
-    : // is of boolean type; therefore narrow type is unknown
-      unknown
-  : // not a boolean
-    false;
 
 export function isFalse<T>(i: T) {
   return (typeof i === "boolean" && !i) as IsFalse<T>;
 }
+
+/**
+ * **ifTrue**
+ *
+ * Strongly type-aware conditional statement which checks whether a value is
+ * a _true_ and returns one of two values (strongly typed) based on the evaluation
+ * of this criteria.
+ *
+ * @param val the value being tested
+ * @param ifVal the value (strongly typed) returned if val is _true_ value
+ * @param elseVal the value (strongly typed) returned if val is NOT a _true_ value
+ *
+ * Note: at runtime there's no way to distinguish if the value was widely or loosely
+ * typed so unlike the type utility there is no "MAYBE" state but if a wide type if
+ * encountered the _type_ will the union of `IF` and `ELSE`.
+ */
+export function ifFalse<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(
+  val: T,
+  ifVal: IF,
+  elseVal: ELSE
+) {
+  return (isFalse(val) ? ifVal : elseVal) as IfFalse<T, IF, ELSE, IF | ELSE>;
+}

package/src/runtime/type-checks/isObject.ts

@@ -1,5 +1,5 @@
 import { FunctionType, Narrowable, Not } from "src/types";
-import { IsObject } from "src/types/type-checks";
+import { IsObject } from "src/types/boolean-logic";
 
 export type ObjectType = Not<Record<string, Narrowable>, FunctionType>;
 

package/src/runtime/type-checks/isString.ts

@@ -1,5 +1,5 @@
 import { Narrowable } from "src/types/Narrowable";
-import { IfString, IsString } from "src/types/type-checks/string";
+import { IfString, IsString } from "src/types/boolean-logic/string";
 
 /**
  * **isString**

package/src/runtime/type-checks/isTrue.ts

@@ -1,28 +1,5 @@
-import { Narrowable } from "src/types";
-import type { IsBoolean } from "./isBoolean";
-
-/**
- * Type utility which returns `true` or `false` based on
- * whether the type holds the narrow "true" type.
- * ```ts
- * // true
- * type T = IsTrue<true>;
- * // unknown
- * type U = IsTrue<boolean>;
- * // false
- * type F = IsTrue<false>;
- * type F2 = IsTrue<"false">;
- * ```
- */
-export type IsTrue<T> = IsBoolean<T> extends true
-  ? // is a boolean
-    T extends true
-    ? true
-    : T extends false
-    ? false
-    : unknown
-  : // not a boolean
-    false;
+import { IfTrue, IsTrue } from "src/types/boolean-logic";
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * Run-time and type checking of whether a variable is `true`.
@@ -41,7 +18,15 @@ export function isTrue<T extends Narrowable>(i: T) {
  * @param val the value being tested
  * @param ifVal the value (strongly typed) returned if val is _true_ value
  * @param elseVal the value (strongly typed) returned if val is NOT a _true_ value
+ *
+ * Note: at runtime there's no way to distinguish if the value was widely or loosely
+ * typed so unlike the type utility there is no "MAYBE" state but if a wide type if
+ * encountered the _type_ will the union of `IF` and `ELSE`.
  */
-export function ifTrue<T extends Narrowable, IF, ELSE>(val: T, ifVal: IF, elseVal: ELSE) {
-  return (isTrue(val) ? ifVal : elseVal) as IsTrue<T> extends true ? IF : ELSE;
+export function ifTrue<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable>(
+  val: T,
+  ifVal: IF,
+  elseVal: ELSE
+) {
+  return (isTrue(val) ? ifVal : elseVal) as IfTrue<T, IF, ELSE, IF | ELSE>;
 }

package/src/runtime/type-checks/isUndefined.ts

@@ -1,5 +1,5 @@
 import { Narrowable } from "src/types";
-import { IsUndefined } from "src/types/type-checks/IsUndefined";
+import { IsUndefined } from "src/types/boolean-logic/IsUndefined";
 
 export function isUndefined<T extends Narrowable>(i: T) {
   return (typeof i === "undefined") as undefined extends T ? true : false;

package/src/runtime/type-checks/startsWith.ts

@@ -1,5 +1,5 @@
-import { IfStartsWith, StartsWith } from "src/types/type-checks";
-import { IfUndefined } from "src/types/type-checks/IsUndefined";
+import { IfStartsWith, StartsWith } from "src/types/boolean-logic";
+import { IfUndefined } from "src/types/boolean-logic/IsUndefined";
 import { createFnWithProps } from "../createFnWithProps";
 import { box, Box } from "../literals";
 import { ifTrue } from "./isTrue";

package/src/types/Mutable.ts

@@ -1,4 +1,4 @@
-import { IsObject } from "./type-checks";
+import { IsObject } from "./boolean-logic";
 
 /**
  * Makes a readonly structure mutable

package/src/types/Narrowable.ts

@@ -2,5 +2,4 @@
  * A union of types used in conjunction with the `literalValues()` function
  * to produce a _narrow_ type definition of a passed in dictionary object.
  */
-export type Narrowable =
-  string | number | boolean | symbol | object | undefined | void | null | {};
+export type Narrowable = string | number | boolean | symbol | object | undefined | void | null | {};

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

@@ -1,4 +1,4 @@
-import { IfStringLiteral } from "src/types/type-checks";
+import { IfStringLiteral } from "src/types/boolean-logic";
 
 /**
  * **EndsWith**<T,U>

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

@@ -1,10 +1,9 @@
 /**
- * **Extends**
+ * **Extends**`<T, EXTENDS>`
  *
- * Boolean type utility which returns `true` if `E` _extends_ `T`.
+ * Boolean type utility which returns `true` if `T` _extends_ `EXTENDS`.
  */
-export type Extends<E, T> = E extends T ? true : false;
-
+export type Extends<T, EXTENDS> = T extends EXTENDS ? true : false;
 /**
  * **IfExtends**
  *

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

@@ -1,4 +1,4 @@
-import { IsBooleanLiteral } from "./IsBooleanLiteral";
+import { IsBooleanLiteral } from "./boolean";
 import { IsStringLiteral } from "./IsStringLiteral";
 import { IsNumericLiteral } from "./IsNumericLiteral";
 

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

@@ -1,4 +1,4 @@
-import { IfStringLiteral } from "src/types/type-checks";
+import { IfStringLiteral } from "src/types/boolean-logic";
 import { Narrowable } from "../Narrowable";
 /**
  * **StartsWith**<TValue, TStartsWith>

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

@@ -1,4 +1,4 @@
-import { IsObject } from "src/types/type-checks";
+import { IsObject } from "src/types/boolean-logic";
 import { SimplifyObject } from "../SimplifyObject";
 import { IfExtends } from "./Extends";
 import { IfOptionalLiteral } from "./IsLiteral";

package/src/types/boolean-logic/array.ts

@@ -0,0 +1,57 @@
+import { Equal } from "../combinators/equivalency";
+import { AfterFirst, First } from "../lists";
+import { Narrowable } from "../Narrowable";
+
+export type IsArray<T> = [T] extends [any[]] ? true : [T] extends [readonly any[]] ? true : false;
+export type IsReadonlyArray<T> = T extends readonly any[] ? true : false;
+
+/**
+ * **IfArray**`<T, IF, ELSE>`
+ *
+ * Type utility which convert to type `IF` or `ELSE` based on whether `T` is an array
+ */
+export type IfArray<
+  T extends Narrowable,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsArray<T> extends true ? IF : ELSE;
+
+/**
+ * **IfArray**`<T, IF, ELSE>`
+ *
+ * Type utility which convert to type `IF` or `ELSE` based on whether `T` is a readonly array
+ */
+export type IfReadonlyArray<
+  T extends Narrowable,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsReadonlyArray<T> extends true ? IF : ELSE;
+
+/**
+ * **Contains**`<T, A>`
+ *
+ * Type utility which checks whether a type `T` exists within an array `A`. Result is
+ * `true` if `T` _extends_ any element in `A` making it match widely against `A`. If you
+ * prefer a narrower match you can use `NarrowlyContains<T,A>` instead.
+ */
+export type Contains<T extends Narrowable, A extends readonly any[]> = First<A> extends T
+  ? true
+  : [] extends AfterFirst<A>
+  ? false
+  : Contains<T, AfterFirst<A>>;
+
+/**
+ * **NarrowlyContains**`<T, A>`
+ *
+ * Type utility which checks whether a type `T` exists within an array `A`. Result is
+ * `true` if `T` _extends_ any element in `A` making it match widely against `A`. If you
+ * prefer a wider match you can use `Contains<T,A>` instead.
+ */
+export type NarrowlyContains<T extends Narrowable, A extends readonly any[]> = Equal<
+  First<A>,
+  T
+> extends true
+  ? true
+  : [] extends AfterFirst<A>
+  ? false
+  : NarrowlyContains<T, AfterFirst<A>>;

package/src/types/boolean-logic/boolean.ts

@@ -0,0 +1,76 @@
+import { Narrowable } from "../Narrowable";
+
+export type IsBoolean<T> = T extends boolean ? true : false;
+
+/**
+ * Type utility which returns `true` or `false` based on
+ * whether the type holds the narrow "true" type.
+ * ```ts
+ * // true
+ * type T = IsTrue<true>;
+ * // boolean
+ * type U = IsTrue<boolean>;
+ * // false
+ * type F = IsTrue<false>;
+ * type F2 = IsTrue<"false">;
+ * ```
+ */
+export type IsTrue<T extends Narrowable> = IsBoolean<T> extends true
+  ? // is a boolean
+    T extends true
+    ? true
+    : T extends false
+    ? false
+    : unknown
+  : // not a boolean
+    false;
+
+export type IsFalse<T extends Narrowable> = IsBoolean<T> extends true
+  ? // is a boolean
+    T extends false
+    ? true
+    : true extends T
+    ? false
+    : // is of boolean type; therefore narrow type is unknown
+      unknown
+  : // not a boolean
+    false;
+
+/**
+ * Type utility which checks for literal `true` value and then switches type
+ * to the IF, ELSE, or MAYBE generic types passed in where _maybe_ is when T
+ * is the wide type of `boolean`
+ */
+export type IfTrue<T, IF, ELSE, MAYBE> = IsTrue<T> extends true
+  ? IF
+  : IsTrue<T> extends false
+  ? ELSE
+  : MAYBE;
+
+/**
+ * Type utility which checks for literal `false` value and then switches type
+ * to the IF, ELSE, or MAYBE generic types passed in where _maybe_ is when T
+ * is the wide type of `boolean`
+ */
+export type IfFalse<T, IF, ELSE, MAYBE> = IsFalse<T> extends true
+  ? IF
+  : IsTrue<T> extends false
+  ? ELSE
+  : MAYBE;
+
+/**
+ * **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 → boolean-logic}/index.ts

@@ -1,5 +1,6 @@
+export * from "./array";
 export * from "./Includes";
-export * from "./IsBooleanLiteral";
+export * from "./boolean";
 export * from "./IsNumericLiteral";
 export * from "./IsScalar";
 export * from "./IsStringLiteral";

package/src/types/combinators/Or.ts

@@ -0,0 +1,12 @@
+import { NarrowlyContains } from "../boolean-logic";
+
+/**
+ * **Or**`<T>`
+ *
+ * Takes an array of boolean values and produces a boolean OR across these values
+ */
+export type Or<T extends readonly boolean[]> = NarrowlyContains<true, T> extends true
+  ? true
+  : NarrowlyContains<boolean, T> extends true
+  ? boolean
+  : false;

package/src/types/combinators/equivalency.ts

@@ -0,0 +1,15 @@
+/**
+ * **Equal**`<X,Y>`
+ *
+ * Type utility which tests whether two types -- `X` and `Y` -- are exactly the same type
+ */
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
+  ? true
+  : false;
+
+/**
+ * **NotEqual**`<X,Y>`
+ *
+ * Type utility which tests whether two types -- `X` and `Y` -- are _not_ exactly the same type
+ */
+export type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;

package/src/types/combinators/index.ts

@@ -0,0 +1,2 @@
+export * from "./equivalency";
+export * from "./Or";

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

@@ -37,11 +37,12 @@ export * from "./fluent/index";
 export * from "./functions/index";
 export * from "./kv/index";
 export * from "./lists/index";
+export * from "./combinators/index";
 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/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, 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);

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;