inferred-types 0.34.0 → 0.35.0

package/dist/index.d.ts

@@ -166,6 +166,19 @@ type AfterFirst<T extends readonly any[]> = T extends readonly [any, ...any[]] ?
  */
 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>`
  *
@@ -280,26 +293,26 @@ type IsFalse<T extends Narrowable> = IsBoolean<T> extends true ? T extends false
  * 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 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, IF, ELSE, MAYBE> = IsFalse<T> extends true ? IF : IsTrue<T> extends false ? ELSE : MAYBE;
+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**
@@ -307,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**
  *
@@ -327,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**
  *
@@ -354,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.
@@ -373,15 +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
+ * Branch type utility which returns `IF` when `T` is a scalar value (aka, string, number, or boolean) and `ELSE` otherwise
  */
-type IfScalar<T, IF, ELSE> = IsScalar<T> extends true ? IF : ELSE;
+type IfScalar<T extends Narrowable, IF extends Narrowable, ELSE extends Narrowable> = IsScalar<T> extends true ? IF : ELSE;
 
 /**
  * **IsUndefined**
@@ -395,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**`<T, EXTENDS>`
  *
  * Boolean type utility which returns `true` if `T` _extends_ `EXTENDS`.
  */
-type Extends<T, EXTENDS> = T extends EXTENDS ? 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
@@ -460,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>
@@ -471,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>
  *
@@ -483,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>
@@ -494,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
@@ -1231,6 +1257,34 @@ type SpaceToDash<T extends string> = T extends `${infer Begin}${" "}${infer Rest
  * ``` */
 type SnakeCase<S extends string> = string extends S ? string : DashUppercase<Uncapitalize<SpaceToDash<Trim<LowerAllCaps<S>>>>> extends `${infer Begin}${"-"}${infer Rest}` ? SnakeCase<`${Lowercase<Begin>}_${Rest}`> : Lowercase<DashUppercase<Uncapitalize<Trim<LowerAllCaps<S>>>>>;
 
+/**
+ * **StripStarting**`<T, U>`
+ *
+ * Will strip off of `T` the starting string defined by `U` when
+ * both are string literals.
+ * ```ts
+ * type T = "Hello World";
+ * type U = "Hello ";
+ * // "World"
+ * type R = StripStarting<T,U>;
+ * ```
+ */
+type StripStarting<T extends string, U extends string> = IfLiteral<T, string extends U ? never : T extends `${U}${infer After}` ? After : T, string>;
+
+/**
+ * **StripEnding**`<T, U>`
+ *
+ * Will strip off of `T` the ending defined by `U` when
+ * both are string literals.
+ * ```ts
+ * type T = "Hello World";
+ * type U = " World";
+ * // "Hello"
+ * type R = StripEnding<T,U>;
+ * ```
+ */
+type StripEnding<T extends string, U extends string> = IfLiteral<T, string extends U ? never : T extends `${infer Before}${U}` ? Before : T, string>;
+
 type NetworkProtocol = "http" | "https" | "file" | "ws" | "wss";
 /**
  * A literal variant of _string_ which is meant to represent a domain name
@@ -1698,13 +1752,6 @@ type KvFrom<T extends object> = Array<{
  */
 type KvTuple<T, K extends keyof T> = [K, Record<K, T[K]>];
 
-/**
- * **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;
-
 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]`.
@@ -2216,6 +2263,10 @@ declare function idTypeGuard<T extends {
  */
 declare function literal<N extends Narrowable, T extends Record<keyof T, N>>(obj: T): T;
 
+declare function stripEnding<T extends string, U extends string>(content: T, strip: U): StripEnding<T, U>;
+
+declare function stripStarting<T extends string, U extends string>(content: T, strip: U): StripStarting<T, U>;
+
 /**
  * **Suggest**
  *
@@ -2280,7 +2331,7 @@ declare function isFalse<T>(i: T): IsFalse<T>;
  * 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>;
+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;
@@ -2353,7 +2404,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**
@@ -2388,8 +2439,7 @@ 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
@@ -2399,7 +2449,7 @@ declare function isTrue<T extends Narrowable>(i: T): IsTrue<T>;
  * 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 extends Narrowable, ELSE extends Narrowable>(val: T, ifVal: IF, elseVal: ELSE): IfTrue<T, IF, ELSE, 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;
 /**
@@ -2523,4 +2573,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, 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 };
+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, StripEnding, StripStarting, 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, stripEnding, stripStarting, type, typeApi, unbox, withValue };

package/dist/index.js

@@ -87,6 +87,8 @@ __export(src_exports, {
   readonlyFnWithProps: () => readonlyFnWithProps,
   ruleSet: () => ruleSet,
   strArrayToDict: () => strArrayToDict,
+  stripEnding: () => stripEnding,
+  stripStarting: () => stripStarting,
   type: () => type,
   typeApi: () => typeApi,
   unbox: () => unbox,
@@ -776,6 +778,18 @@ function idTypeGuard(_o) {
 function literal(obj) {
   return obj;
 }
+
+// src/runtime/literals/stripEnding.ts
+function stripEnding(content, strip) {
+  const re = new RegExp(`(.*)${strip}$`);
+  return content.endsWith(strip) ? content.replace(re, "$1") : content;
+}
+
+// src/runtime/literals/stripStarting.ts
+function stripStarting(content, strip) {
+  const re = new RegExp(`^${strip}(.*)`);
+  return content.startsWith(strip) ? content.replace(re, "$1") : content;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Configurator,
@@ -845,6 +859,8 @@ function literal(obj) {
   readonlyFnWithProps,
   ruleSet,
   strArrayToDict,
+  stripEnding,
+  stripStarting,
   type,
   typeApi,
   unbox,

package/dist/index.mjs

@@ -680,6 +680,18 @@ function idTypeGuard(_o) {
 function literal(obj) {
   return obj;
 }
+
+// src/runtime/literals/stripEnding.ts
+function stripEnding(content, strip) {
+  const re = new RegExp(`(.*)${strip}$`);
+  return content.endsWith(strip) ? content.replace(re, "$1") : content;
+}
+
+// src/runtime/literals/stripStarting.ts
+function stripStarting(content, strip) {
+  const re = new RegExp(`^${strip}(.*)`);
+  return content.startsWith(strip) ? content.replace(re, "$1") : content;
+}
 export {
   Configurator,
   DEFAULT_MANY_TO_ONE_MAPPING,
@@ -748,6 +760,8 @@ export {
   readonlyFnWithProps,
   ruleSet,
   strArrayToDict,
+  stripEnding,
+  stripStarting,
   type,
   typeApi,
   unbox,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inferred-types",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Functions which provide useful type inference on TS projects",
   "license": "MIT",
   "author": "Ken Snyder<ken@ken.net>",
@@ -32,16 +32,16 @@
   },
   "devDependencies": {
     "@type-challenges/utils": "~0.1.1",
-    "@types/node": "^16.18.3",
-    "@typescript-eslint/eslint-plugin": "^5.45.0",
-    "@typescript-eslint/parser": "^5.45.0",
-    "@vitest/ui": "^0.25.3",
+    "@types/node": "^16.18.4",
+    "@typescript-eslint/eslint-plugin": "^5.45.1",
+    "@typescript-eslint/parser": "^5.45.1",
+    "@vitest/ui": "^0.25.4",
     "bumpp": "^8.2.1",
     "common-types": "^1.33.2",
     "cross-env": "^7.0.3",
     "dd": "^0.25.4",
     "dotenv": "^16.0.3",
-    "eslint": "^8.28.0",
+    "eslint": "^8.29.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-prettier": "^4.2.1",
@@ -53,8 +53,8 @@
     "sharp": "^0.31.2",
     "tsup": "^6.5.0",
     "typescript": "^4.9.3",
-    "vite": "^3.2.4",
-    "vitest": "^0.25.3"
+    "vite": "^3.2.5",
+    "vitest": "^0.25.4"
   },
   "dependencies": {
     "brilliant-errors": "^0.6.1"

package/src/runtime/combinators/or.ts

@@ -1,4 +1,4 @@
-import { Or } from "src/types/combinators/Or";
+import { Or } from "src/types/boolean-logic/Or";
 
 export function or<O extends readonly boolean[]>(...conditions: O) {
   return (conditions.some((v) => v === true) ? true : false) as Or<O>;

package/src/runtime/literals/index.ts

@@ -10,6 +10,8 @@ export * from "./box";
 export * from "./defineType";
 export * from "./identity";
 export * from "./literal";
+export * from "./stripEnding";
+export * from "./stripStarting";
 export * from "./Suggest";
 
 // #endregion auto-indexed files

package/src/runtime/literals/pathJoin.ts

@@ -0,0 +1,17 @@
+import { PathJoin } from "src/types/alphabetic/PathJoin";
+import { stripStarting } from "./stripStarting";
+import { stripEnding } from "./stripEnding";
+
+/**
+ * **pathJoin**`<T,U>()`
+ *
+ * Run time utility which joins two strings together with
+ * the intent to have them be divided by a Posix `/` character
+ * appropriate for Unix file paths and URLs.
+ */
+export function pathJoin<T extends string, U extends string>(begin: T, finish: U): PathJoin<T, U> {
+  const start = stripEnding(begin, "/");
+  const end = stripStarting(finish, "/");
+
+  return `${start}/${end}` as PathJoin<T, U>;
+}

package/src/runtime/literals/stripEnding.ts

@@ -0,0 +1,9 @@
+import { StripEnding } from "src/types/alphabetic/StripEnding";
+
+export function stripEnding<T extends string, U extends string>(
+  content: T,
+  strip: U
+): StripEnding<T, U> {
+  const re = new RegExp(`(.*)${strip}$`);
+  return (content.endsWith(strip) ? content.replace(re, "$1") : content) as StripEnding<T, U>;
+}

package/src/runtime/literals/stripStarting.ts

@@ -0,0 +1,15 @@
+import { StripStarting } from "src/types/alphabetic/StripStarting";
+
+export function stripStarting<T extends string, U extends string>(
+  content: T,
+  strip: U
+): StripStarting<T, U> {
+  const re = new RegExp(`^${strip}(.*)`);
+  return (
+    content.startsWith(strip)
+      ? // starts with
+        content.replace(re, "$1")
+      : // does not
+        content
+  ) as StripStarting<T, U>;
+}

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

@@ -20,7 +20,7 @@ export function isFalse<T>(i: T) {
  * 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>(
+export function ifFalse<T extends boolean, IF extends Narrowable, ELSE extends Narrowable>(
   val: T,
   ifVal: IF,
   elseVal: ELSE

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

@@ -12,8 +12,7 @@ export function isTrue<T extends Narrowable>(i: 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
@@ -23,7 +22,7 @@ export function isTrue<T extends Narrowable>(i: T) {
  * 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 extends Narrowable, ELSE extends Narrowable>(
+export function ifTrue<T extends boolean, IF extends Narrowable, ELSE extends Narrowable>(
   val: T,
   ifVal: IF,
   elseVal: ELSE

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

@@ -1,3 +1,4 @@
+import { Narrowable } from "src/types";
 import { IfStartsWith, StartsWith } from "src/types/boolean-logic";
 import { IfUndefined } from "src/types/boolean-logic/IsUndefined";
 import { createFnWithProps } from "../createFnWithProps";
@@ -88,22 +89,19 @@ export type StringLiteralFn<S extends string = string> = <T extends S>(input: T)
  * returns is able to
  */
 export const ifStartsWith =
-  <
-    TStartsWith extends string,
-    TIf extends <T extends string>(input: T) => any,
-    TElse extends <T extends string>(input: T) => any
-  >(
+  <TStartsWith extends string, TIf extends Narrowable, TElse extends Narrowable>(
     /** the string literal _start value_ which a string must begin with */
     start: TStartsWith,
     /** a mutation function when a value _does_ start with `TStartsWith` */
-    isTrue: TIf,
+    isTrue: <T extends string>(input: T) => TIf,
     /** an optional mutation function */
-    isFalse: TElse
+    isFalse: <T extends string>(input: T) => TElse
   ) =>
-  <I extends string>(input: I) =>
+  <TTextValue extends string>(input: TTextValue) =>
     ifTrue(
       // condition
       startsWith(start)(input),
+      // handlers
       isTrue(input),
       isFalse(input)
-    ) as IfStartsWith<I, TStartsWith, ReturnType<TIf>, ReturnType<TElse>>;
+    );

package/src/types/alphabetic/PathJoin.ts

@@ -0,0 +1,40 @@
+import { IfLiteral } from "../boolean-logic";
+import { StripEnding } from "./StripEnding";
+import { StripStarting } from "./StripStarting";
+/**
+ * **PathJoin**`<T,U>`
+ *
+ * Type utility which joins two strings together with the
+ * goal of making it a valid file or URI path (based on the
+ * Posix standard for file paths).
+ *
+ * Primarily, this means that it ensures that both `T` and `U`
+ * are separated by a single `/` character. Of course if either
+ * `T` or `U` are _wide_ string types then the resulting type
+ * will be more limited.
+ *
+ * **Note:** that in the case that both `T` and `U` are wide,
+ * we opt to type the result as just a _string_ rather than
+ * `${string}/${string}` which might be more precise 99% of
+ * the time but where `T` is an empty string there actually
+ * is no guarantee of a `/` character. Similarly we must
+ * type the case where `U` is narrow but `T` is wide as
+ * being `${string}${U}` instead of `${string}/${U}`.
+ */
+export type PathJoin<
+  // leading string
+  T extends string,
+  // trailing string
+  U extends string
+> = IfLiteral<
+  T,
+  // Literal T guaranteed
+  IfLiteral<
+    // conditional
+    U,
+    `${StripEnding<T, "/">}/${StripStarting<U, "/">}`,
+    `${StripEnding<T, "/">}/${string}`
+  >,
+  // wide `T` encountered
+  IfLiteral<U, `${string}${U}`, string>
+>;

package/src/types/alphabetic/StripEnding.ts

@@ -0,0 +1,23 @@
+import { IfLiteral } from "../boolean-logic/IsLiteral";
+
+/**
+ * **StripEnding**`<T, U>`
+ *
+ * Will strip off of `T` the ending defined by `U` when
+ * both are string literals.
+ * ```ts
+ * type T = "Hello World";
+ * type U = " World";
+ * // "Hello"
+ * type R = StripEnding<T,U>;
+ * ```
+ */
+export type StripEnding<T extends string, U extends string> = IfLiteral<
+  // can only operate on literal strings
+  T,
+  // this path represents successful strip opp
+  // but we must never accept `U` being wide
+  string extends U ? never : T extends `${infer Before}${U}` ? Before : T,
+  // here we must stay wide
+  string
+>;

package/src/types/alphabetic/StripStarting.ts

@@ -0,0 +1,23 @@
+import { IfLiteral } from "../boolean-logic/IsLiteral";
+
+/**
+ * **StripStarting**`<T, U>`
+ *
+ * Will strip off of `T` the starting string defined by `U` when
+ * both are string literals.
+ * ```ts
+ * type T = "Hello World";
+ * type U = "Hello ";
+ * // "World"
+ * type R = StripStarting<T,U>;
+ * ```
+ */
+export type StripStarting<T extends string, U extends string> = IfLiteral<
+  // can only operate on literal strings
+  T,
+  // this path represents successful strip opp
+  // but we must never accept `U` being wide
+  string extends U ? never : T extends `${U}${infer After}` ? After : T,
+  // here we must stay wide
+  string
+>;

package/src/types/alphabetic/index.ts

@@ -18,6 +18,8 @@ export * from "./LowerAllCaps";
 export * from "./PascalCase";
 export * from "./Pluralize";
 export * from "./SnakeCase";
+export * from "./StripStarting";
+export * from "./StripEnding";
 export * from "./alpha-characters";
 export * from "./Url";
 

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

@@ -1,4 +1,5 @@
-import { IfStringLiteral } from "src/types/boolean-logic";
+import { IsStringLiteral } from "src/types/boolean-logic";
+import { Narrowable } from "../Narrowable";
 
 /**
  * **EndsWith**<T,U>
@@ -9,14 +10,31 @@ import { IfStringLiteral } from "src/types/boolean-logic";
  * 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;
+export type EndsWith<
+  TValue extends string,
+  TEndsWith extends string
+> = IsStringLiteral<TEndsWith> extends true
+  ? IsStringLiteral<TValue> extends true // both literals
+    ? 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.
+ */
+export 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;

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

@@ -1,13 +1,22 @@
+import { Narrowable } from "../Narrowable";
+
 /**
  * **Extends**`<T, EXTENDS>`
  *
  * Boolean type utility which returns `true` if `T` _extends_ `EXTENDS`.
  */
-export type Extends<T, EXTENDS> = T extends EXTENDS ? true : false;
+export 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`.
  */
-export type IfExtends<E, T, IF, ELSE> = Extends<E, T> extends true ? IF : ELSE;
+export type IfExtends<
+  T extends Narrowable,
+  EXTENDS extends Narrowable,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = Extends<T, EXTENDS> extends true ? IF : ELSE;

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

@@ -1,9 +1,8 @@
 import { TupleToUnion } from "../type-conversion";
-import { IsLiteral } from "./IsLiteral";
-import { IsStringLiteral } from "./IsStringLiteral";
+import { IsLiteral, IsStringLiteral } from "./IsLiteral";
 
 /**
- * **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.
@@ -13,7 +12,7 @@ import { IsStringLiteral } from "./IsStringLiteral";
  * a type of `boolean`.
  */
 export type Includes<
-  TSource extends string | string[],
+  TSource extends string | readonly string[],
   TValue extends string
 > = TSource extends string[]
   ? IsStringLiteral<TupleToUnion<TSource>> extends true

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

@@ -1,6 +1,47 @@
+import { Narrowable } from "../Narrowable";
 import { IsBooleanLiteral } from "./boolean";
-import { IsStringLiteral } from "./IsStringLiteral";
-import { IsNumericLiteral } from "./IsNumericLiteral";
+
+/**
+ * **IsStringLiteral**
+ *
+ * Type utility which returns true/false if the string a _string literal_ versus
+ * just the _string_ type.
+ */
+export 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
+ */
+export type IfStringLiteral<T extends string, IF extends Narrowable, ELSE extends Narrowable> = [
+  IsStringLiteral<T>
+] extends [true]
+  ? IF
+  : ELSE;
+
+/**
+ * **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 extends Narrowable,
+  ELSE extends Narrowable
+> = IsNumericLiteral<T> extends true ? IF : ELSE;
 
 // [note on handling of boolean](https://stackoverflow.com/questions/74213646/detecting-type-literals-works-in-isolation-but-not-when-combined-with-other-lite/74213713#74213713)
 
@@ -43,7 +84,9 @@ export type IsOptionalLiteral<T> = [Exclude<T, undefined>] extends [string]
  *
  * Branch type utility with return `IF` when `T` is a _literal_ value and `ELSE` otherwise
  */
-export type IfLiteral<T, IF, ELSE> = IsLiteral<T> extends true ? IF : ELSE;
+export type IfLiteral<T, IF extends Narrowable, ELSE extends Narrowable> = IsLiteral<T> extends true
+  ? IF
+  : ELSE;
 
 /**
  * **IfOptionalLiteral**
@@ -51,4 +94,8 @@ export type IfLiteral<T, IF, ELSE> = IsLiteral<T> extends true ? IF : ELSE;
  * Branch type utility with return `IF` when `T` is a _literal_ value (with possibly
  * the inclusion of _undefined_); otherwise returns the type `ELSE`
  */
-export type IfOptionalLiteral<T, IF, ELSE> = IsOptionalLiteral<T> extends true ? IF : ELSE;
+export type IfOptionalLiteral<
+  T,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsOptionalLiteral<T> extends true ? IF : ELSE;

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

@@ -1,4 +1,6 @@
-export type IsScalar<T> = [T] extends [string]
+import { Narrowable } from "../Narrowable";
+
+export type IsScalar<T extends Narrowable> = [T] extends [string]
   ? true
   : [T] extends [number]
   ? true
@@ -7,8 +9,12 @@ export type IsScalar<T> = [T] extends [string]
   : false;
 
 /**
- * **IfScalar**
+ * **IfScalar**`<T, IF, ELSE>`
  *
- * Branch type utility which returns `IF` when `T` is a scalar value and `ELSE` otherwise
+ * Branch type utility which returns `IF` when `T` is a scalar value (aka, string, number, or boolean) and `ELSE` otherwise
  */
-export type IfScalar<T, IF, ELSE> = IsScalar<T> extends true ? IF : ELSE;
+export type IfScalar<
+  T extends Narrowable,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsScalar<T> extends true ? IF : ELSE;

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

@@ -13,4 +13,8 @@ export type IsUndefined<T extends Narrowable> = T extends undefined ? true : fal
  * Type utility which returns `IF` type when `T` is an _undefined_
  * otherwise returns `ELSE` type.
  */
-export type IfUndefined<T, IF, ELSE> = IsUndefined<T> extends true ? IF : ELSE;
+export type IfUndefined<
+  T,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsUndefined<T> extends true ? IF : ELSE;

package/src/types/{combinators → boolean-logic}/Or.ts

@@ -1,4 +1,4 @@
-import { NarrowlyContains } from "../boolean-logic";
+import { NarrowlyContains } from "./array";
 
 /**
  * **Or**`<T>`

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

@@ -1,4 +1,4 @@
-import { IfStringLiteral } from "src/types/boolean-logic";
+import { IsStringLiteral } from "src/types/boolean-logic";
 import { Narrowable } from "../Narrowable";
 /**
  * **StartsWith**<TValue, TStartsWith>
@@ -9,17 +9,16 @@ import { Narrowable } from "../Narrowable";
  * 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 StartsWith<TValue extends unknown, TStartsWith extends unknown> = TValue extends string
-  ? TStartsWith extends string
+export type StartsWith<
+  TValue extends string,
+  TStartsWith extends string
+> = IsStringLiteral<TStartsWith> extends true
+  ? IsStringLiteral<TValue> extends true // both literals
     ? TValue extends `${TStartsWith}${string}`
-      ? IfStringLiteral<
-          TValue, //
-          IfStringLiteral<TStartsWith, true, boolean>,
-          boolean
-        >
-      : IfStringLiteral<TValue, false, boolean>
-    : false
-  : false;
+      ? true
+      : false
+    : boolean
+  : boolean;
 
 /**
  * **IfStartsWith**<TValue, TStartsWith, IF, ELSE, MAYBE>
@@ -32,8 +31,8 @@ export type StartsWith<TValue extends unknown, TStartsWith extends unknown> = TV
  * type and therefore the type is unknown at design time.
  */
 export type IfStartsWith<
-  TValue extends unknown,
-  TStartsWith extends unknown,
+  TValue extends string,
+  TStartsWith extends string,
   IF extends Narrowable,
   ELSE extends Narrowable
 > = StartsWith<TValue, TStartsWith> extends true

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

@@ -1,4 +1,4 @@
-import { Equal } from "../combinators/equivalency";
+import { Equal } from "./equivalency";
 import { AfterFirst, First } from "../lists";
 import { Narrowable } from "../Narrowable";
 

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

@@ -41,22 +41,24 @@ export type IsFalse<T extends Narrowable> = IsBoolean<T> extends true
  * 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;
+export 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`
  */
-export type IfFalse<T, IF, ELSE, MAYBE> = IsFalse<T> extends true
-  ? IF
-  : IsTrue<T> extends false
-  ? ELSE
-  : MAYBE;
+export 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**
@@ -64,13 +66,19 @@ export type IfFalse<T, IF, ELSE, MAYBE> = IsFalse<T> extends true
  * 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;
+export 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
  */
-export type IfBooleanLiteral<T extends boolean, IF, ELSE> = IsBooleanLiteral<T> extends true
-  ? IF
-  : ELSE;
+export type IfBooleanLiteral<
+  T extends boolean,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsBooleanLiteral<T> extends true ? IF : ELSE;

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

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

package/src/types/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/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/index.ts

@@ -37,7 +37,6 @@ 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";

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/literals/PathJoin.test.ts

@@ -0,0 +1,87 @@
+import { Equal, Expect } from "@type-challenges/utils";
+import { pathJoin } from "src/runtime/literals/pathJoin";
+import { PathJoin } from "src/types/alphabetic/PathJoin";
+import { describe, expect, it } from "vitest";
+
+// Note: type tests fail visible inspection but pass from Vitest
+// standpoint so always be sure to run `tsc --noEmit` over your test files to
+// gain validation that no new type vulnerabilities have cropped up.
+
+describe("PathJoin<T,U>", () => {
+  it("only literals / happy path", () => {
+    type T1 = PathJoin<"foo", "bar">;
+    type T2 = PathJoin<"foo/", "bar">;
+    type T3 = PathJoin<"foo", "/bar">;
+    type T4 = PathJoin<"foo/", "/bar">;
+
+    type cases = [
+      // neither have divider
+      Expect<Equal<T1, "foo/bar">>,
+      // one has, one does not
+      Expect<Equal<T2, "foo/bar">>,
+      Expect<Equal<T3, "foo/bar">>,
+      // both have
+      Expect<Equal<T4, "foo/bar">>
+    ];
+    const cases: cases = [true, true, true, true];
+  });
+
+  it("wide types mixed in", () => {
+    type T1 = PathJoin<"foo", string>;
+    type T2 = PathJoin<"foo/", string>;
+    type T3 = PathJoin<string, "/bar">;
+    type T4 = PathJoin<string, "bar">;
+
+    type cases = [
+      Expect<Equal<T1, `foo/${string}`>>,
+      Expect<Equal<T2, `foo/${string}`>>,
+      Expect<Equal<T3, `${string}/bar`>>,
+      Expect<Equal<T4, `${string}bar`>>
+    ];
+    const cases: cases = [true, true, true, true];
+  });
+});
+
+describe("pathJoin() runtime util", () => {
+  it("happy path", () => {
+    const t1 = pathJoin("foo", "bar" as string);
+    const t2 = pathJoin("foo/", "bar" as string);
+    const t3 = pathJoin("foo" as string, "/bar");
+    const t4 = pathJoin("foo/" as string, "/bar");
+    const t5 = pathJoin("foo/" as string, "bar");
+
+    // runtime tests
+    [t1, t2, t3, t4].forEach((test) => expect(test).toBe("foo/bar"));
+
+    // type tests
+    type cases = [
+      Expect<Equal<typeof t1, `foo/${string}`>>,
+      Expect<Equal<typeof t2, `foo/${string}`>>,
+      Expect<Equal<typeof t3, `${string}/bar`>>,
+      Expect<Equal<typeof t4, `${string}/bar`>>,
+      Expect<Equal<typeof t5, `${string}bar`>>
+    ];
+    const cases: cases = [true, true, true, true, true];
+  });
+
+  it("with wide types", () => {
+    const t1 = pathJoin("foo", "bar");
+    const t2 = pathJoin("foo/", "bar");
+    const t3 = pathJoin("foo", "/bar");
+    const t4 = pathJoin("foo/", "/bar");
+    // runtime tests
+    [t1, t2, t3, t4].forEach((test) => expect(test, "runtime failure").toBe("foo/bar"));
+
+    // type tests
+    type cases = [
+      // neither have divider
+      Expect<Equal<typeof t1, "foo/bar">>,
+      // one has, one does not
+      Expect<Equal<typeof t2, "foo/bar">>,
+      Expect<Equal<typeof t3, "foo/bar">>,
+      // both have
+      Expect<Equal<typeof t4, "foo/bar">>
+    ];
+    const cases: cases = [true, true, true, true];
+  });
+});

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

@@ -11,7 +11,7 @@ import {
   ifUndefined,
   isTrue,
 } from "src/runtime/type-checks";
-import { EndsWith, Extends, Or, 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";
@@ -236,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>", () => {
@@ -288,7 +295,7 @@ describe("runtime if/is", () => {
       // condition
       "foo",
       // inline
-      (i) => `welcome ${i}` as const,
+      (i) => `welcome ${i}`,
       // external
       noSir
     );

package/src/types/boolean-logic/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/boolean-logic/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;

package/src/types/combinators/index.ts

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