inferred-types 0.33.4 → 0.34.2

package/.vscode/settings.json

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

package/dist/index.d.ts

@@ -141,6 +141,110 @@ 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;
+
+/**
+ * **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>;
+ * ```
+ */
+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;
+
+/**
+ * **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,19 +272,47 @@ 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 extends boolean, IF extends Narrowable, ELSE extends Narrowable, MAYBE extends Narrowable> = 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 extends Narrowable, IF extends Narrowable, ELSE extends Narrowable, MAYBE extends Narrowable> = 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.
  */
-type IsBooleanLiteral<T extends boolean> = boolean extends T ? false : true;
+type IsBooleanLiteral<T extends Narrowable> = IsTrue<T> extends true ? true : IsFalse<T> extends true ? true : false;
 /**
  * **IfBooleanLiteral**
  *
  * Branch utility which returns `IF` type when `T` is a boolean literal and `ELSE` otherwise
  */
-type IfBooleanLiteral<T extends boolean, IF, ELSE> = IsBooleanLiteral<T> extends true ? IF : ELSE;
+type IfBooleanLiteral<T extends boolean, IF extends Narrowable, ELSE extends Narrowable> = IsBooleanLiteral<T> extends true ? IF : ELSE;
 
 /**
  * **IsStringLiteral**
@@ -188,14 +320,15 @@ type IfBooleanLiteral<T extends boolean, IF, ELSE> = IsBooleanLiteral<T> extends
  * Type utility which returns true/false if the string a _string literal_ versus
  * just the _string_ type.
  */
-type IsStringLiteral<T> = [T] extends [string] ? (string extends T ? false : true) : false;
+type IsStringLiteral<T extends Narrowable> = [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
  */
-type IfStringLiteral<T, IF, ELSE> = [IsStringLiteral<T>] extends [true] ? IF : ELSE;
-
+type IfStringLiteral<T extends string, IF extends Narrowable, ELSE extends Narrowable> = [
+    IsStringLiteral<T>
+] extends [true] ? IF : ELSE;
 /**
  * **IsNumericLiteral**
  *
@@ -208,8 +341,7 @@ type IsNumericLiteral<T extends number> = number extends T ? false : true;
  *
  * Branch utility which returns `IF` type when `T` is a numeric literal and `ELSE` otherwise
  */
-type IfNumericLiteral<T extends number, IF, ELSE> = IsNumericLiteral<T> extends true ? IF : ELSE;
-
+type IfNumericLiteral<T extends number, IF extends Narrowable, ELSE extends Narrowable> = IsNumericLiteral<T> extends true ? IF : ELSE;
 /**
  * **IsLiteral**
  *
@@ -235,17 +367,17 @@ type IsOptionalLiteral<T> = [Exclude<T, undefined>] extends [string] ? IsStringL
  *
  * Branch type utility with return `IF` when `T` is a _literal_ value and `ELSE` otherwise
  */
-type IfLiteral<T, IF, ELSE> = IsLiteral<T> extends true ? IF : ELSE;
+type IfLiteral<T, IF extends Narrowable, ELSE extends Narrowable> = IsLiteral<T> extends true ? IF : ELSE;
 /**
  * **IfOptionalLiteral**
  *
  * Branch type utility with return `IF` when `T` is a _literal_ value (with possibly
  * the inclusion of _undefined_); otherwise returns the type `ELSE`
  */
-type IfOptionalLiteral<T, IF, ELSE> = IsOptionalLiteral<T> extends true ? IF : ELSE;
+type IfOptionalLiteral<T, IF extends Narrowable, ELSE extends Narrowable> = IsOptionalLiteral<T> extends true ? IF : ELSE;
 
 /**
- * **Includes<TSource, TValue>**
+ * **Includes**`<TSource, TValue>`
  *
  * Type utility which returns `true` or `false` based on whether `TValue` is found
  * in `TSource`. Where `TSource` can be a string literal or an array of string literals.
@@ -254,21 +386,15 @@ type IfOptionalLiteral<T, IF, ELSE> = IsOptionalLiteral<T> extends true ? IF : E
  * no way to know at design-time whether the value includes `TValue` and so it will return
  * a type of `boolean`.
  */
-type Includes<TSource extends string | string[], TValue extends string> = TSource extends string[] ? IsStringLiteral<TupleToUnion<TSource>> extends true ? IsLiteral<TValue> extends true ? TValue extends TupleToUnion<TSource> ? true : false : boolean : boolean : TSource extends string ? IsLiteral<TSource> extends true ? IsLiteral<TValue> extends true ? TSource extends `${string}${TValue}${string}` ? true : false : boolean : boolean : boolean;
+type Includes<TSource extends string | readonly string[], TValue extends string> = TSource extends string[] ? IsStringLiteral<TupleToUnion<TSource>> extends true ? IsLiteral<TValue> extends true ? TValue extends TupleToUnion<TSource> ? true : false : boolean : boolean : TSource extends string ? IsLiteral<TSource> extends true ? IsLiteral<TValue> extends true ? TSource extends `${string}${TValue}${string}` ? true : false : boolean : boolean : boolean;
 
-type IsScalar<T> = [T] extends [string] ? true : [T] extends [number] ? true : [T] extends [boolean] ? true : false;
+type IsScalar<T extends Narrowable> = [T] extends [string] ? true : [T] extends [number] ? true : [T] extends [boolean] ? true : false;
 /**
- * **IfScalar**
+ * **IfScalar**`<T, IF, ELSE>`
  *
- * Branch type utility which returns `IF` when `T` is a scalar value and `ELSE` otherwise
- */
-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.
+ * Branch type utility which returns `IF` when `T` is a scalar value (aka, string, number, or boolean) and `ELSE` otherwise
  */
-type Narrowable = string | number | boolean | symbol | object | undefined | void | null | {};
+type IfScalar<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable> = IsScalar<T> extends true ? IF : ELSE;
 
 /**
  * **IsUndefined**
@@ -282,21 +408,21 @@ type IsUndefined<T extends Narrowable> = T extends undefined ? true : false;
  * Type utility which returns `IF` type when `T` is an _undefined_
  * otherwise returns `ELSE` type.
  */
-type IfUndefined<T, IF, ELSE> = IsUndefined<T> extends true ? IF : ELSE;
+type IfUndefined<T, IF extends Narrowable, ELSE extends Narrowable> = 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 Narrowable, EXTENDS extends Narrowable> = T extends EXTENDS ? true : false;
 /**
  * **IfExtends**
  *
  * Branching type utility which returns type `IF` when `E` _extends_ `T`; otherwise
  * it will return the type `ELSE`.
  */
-type IfExtends<E, T, IF, ELSE> = Extends<E, T> extends true ? IF : ELSE;
+type IfExtends<T extends Narrowable, EXTENDS extends Narrowable, IF extends Narrowable, ELSE extends Narrowable> = Extends<T, EXTENDS> extends true ? IF : ELSE;
 
 /**
  * Often when mutating the shape of an object you will end up with the union of a number of
@@ -347,7 +473,7 @@ type IsObject<T> = Mutable<T> extends Record<string, any> ? T extends FunctionTy
  * Branch type utility with return `IF` when `T` extends an object type
  * and `ELSE` otherwise
  */
-type IfObject<T, IF, ELSE> = IsObject<T> extends true ? IF : ELSE;
+type IfObject<T, IF extends Narrowable, ELSE extends Narrowable> = IsObject<T> extends true ? IF : ELSE;
 
 /**
  * **StartsWith**<TValue, TStartsWith>
@@ -358,8 +484,7 @@ type IfObject<T, IF, ELSE> = IsObject<T> extends true ? IF : ELSE;
  * 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..
  */
-type StartsWith<TValue extends unknown, TStartsWith extends unknown> = TValue extends string ? TStartsWith extends string ? TValue extends `${TStartsWith}${string}` ? IfStringLiteral<TValue, //
-IfStringLiteral<TStartsWith, true, boolean>, boolean> : IfStringLiteral<TValue, false, boolean> : false : false;
+type StartsWith<TValue extends string, TStartsWith extends string> = IsStringLiteral<TStartsWith> extends true ? IsStringLiteral<TValue> extends true ? TValue extends `${TStartsWith}${string}` ? true : false : boolean : boolean;
 /**
  * **IfStartsWith**<TValue, TStartsWith, IF, ELSE, MAYBE>
  *
@@ -370,7 +495,7 @@ IfStringLiteral<TStartsWith, true, boolean>, boolean> : IfStringLiteral<TValue,
  * which can be stated for cases where TValue or TStartsWith _might_ be the wider `string`
  * type and therefore the type is unknown at design time.
  */
-type IfStartsWith<TValue extends unknown, TStartsWith extends unknown, IF extends Narrowable, ELSE extends Narrowable> = StartsWith<TValue, TStartsWith> extends true ? IF : StartsWith<TValue, TStartsWith> extends false ? ELSE : IF | ELSE;
+type IfStartsWith<TValue extends string, TStartsWith extends string, IF extends Narrowable, ELSE extends Narrowable> = StartsWith<TValue, TStartsWith> extends true ? IF : StartsWith<TValue, TStartsWith> extends false ? ELSE : IF | ELSE;
 
 /**
  * **EndsWith**<T,U>
@@ -381,8 +506,22 @@ type IfStartsWith<TValue extends unknown, TStartsWith extends unknown, IF extend
  * 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..
  */
-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;
+type EndsWith<TValue extends string, TEndsWith extends string> = IsStringLiteral<TEndsWith> extends true ? IsStringLiteral<TValue> extends true ? TValue extends `${string}${TEndsWith}` ? true : false : boolean : boolean;
+/**
+ * **IfEndsWith**<TValue, TEndsWith, IF, ELSE, MAYBE>
+ *
+ * Type utility which converts type to `IF` type _if_ `TValue` _ends with_ `TEndsWith` but
+ * otherwise converts type to `ELSE`. If there are wide types in the mix then the type will
+ * result in the union of IF and ELSE.
+ */
+type IfEndsWith<TValue extends string, TEndsWith extends string, IF extends Narrowable, ELSE extends Narrowable> = EndsWith<TValue, TEndsWith> extends true ? IF : EndsWith<TValue, TEndsWith> extends false ? ELSE : IF | ELSE;
+
+/**
+ * **Or**`<T>`
+ *
+ * Takes an array of boolean values and produces a boolean OR across these values
+ */
+type Or<T extends readonly boolean[]> = NarrowlyContains<true, T> extends true ? true : NarrowlyContains<boolean, T> extends true ? boolean : false;
 
 /**
  * Makes a readonly structure mutable
@@ -1212,14 +1351,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 +1675,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;
@@ -1593,39 +1724,6 @@ type KvFrom<T extends object> = Array<{
  */
 type KvTuple<T, K extends keyof T> = [K, Record<K, T[K]>];
 
-/**
- * **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];
-
-/**
- * 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 DictArrayFilterCallback<K extends keyof T, T extends object, R extends true | false> = (key: K, value: Pick<T, K>) => R;
 /**
  * An element in a `DictArray` shaped as a two element tuple: `[key, kv]`.
@@ -1738,13 +1836,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 +2257,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 +2283,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 boolean, 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;
@@ -2260,7 +2372,7 @@ type IsString<T> = T extends string ? true : false;
  * returns `IF` type if it is, otherwise returns the type `ELSE`.
  */
 type IfString<T extends Narrowable, //
-IF extends Narrowable, ELSE extends Narrowable> = IsString<T> extends true ? IF : ELSE;
+IF extends Narrowable, ELSE extends Narrowable> = IsString<T> extends true ? IF : IsString<T> extends false ? ELSE : IF | ELSE;
 
 /**
  * **isString**
@@ -2287,20 +2399,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`.
  */
@@ -2309,14 +2407,17 @@ declare function isTrue<T extends Narrowable>(i: T): IsTrue<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.
+ * _true_.
  *
  * @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 boolean, 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 +2541,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, FilterTuple, FinalReturn, FinalizedMapConfig, First, FirstKey, FirstKeyValue, FirstOfEach, FirstOrUndefined, FirstString, FluentConfigurator, FluentFunction, FnShape, FromDictArray, FullyQualifiedUrl, FunctionType, GeneralDictionary, Get, HasUppercase, HybridFunction, IConfigurator, IFluentConfigurator, If, IfArray, IfBooleanLiteral, IfEndsWith, 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.2",
   "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"
   },