inferred-types 0.51.1 → 0.51.3

package/src/types/type-conversion/Merge.ts

@@ -1,124 +0,0 @@
-import {
-  IsUndefined ,
-  DoesExtend,
-  If,
-  And ,
-  Narrowable,
-  AfterFirst ,
-  First ,
-  Scalar,
-  MergeObjects,
-  Dictionary,
-  AsDictionary,
-  AreSameType,
-  Throw,
-  Or,
-  IsNothing,
-  Nothing
-} from "inferred-types/dist/types/index";
-
-// 1. Keep all unique keys in `TValue`
-// 2. Strip all KV's on `TValue` which are _undefined_
-// 3. Add all unique props from `TDefaultVal`
-
-
-/**
- * **MergeScalars**`<TDefault, TOverride, [TEmpty]>`
- *
- * Provides a `Scalar` value by evaluating whether `TDefault`
- * and `TOverride` extends `TEmpty` (which is `null` | `undefined`
- * by default).
- *
- * Note: if both `TDefault` and `TOverride` are _undefined_ then the
- * exiting type will be _undefined_ (which isn't strictly a `Scalar`
- * value).
- */
-export type MergeScalars<
-  TDefault extends Scalar | undefined,
-  TOverride extends Scalar | undefined,
-  TEmpty extends Scalar | undefined = null | undefined
-> = TDefault extends TEmpty
-? TOverride
-: TOverride extends TEmpty
-  ? TDefault : TOverride;
-
-
-
-type MergeTuplesAcc<
-  TDefault extends readonly unknown[],
-  TOverride extends readonly unknown[],
-  TKey extends string | false = false,
-  TResults extends readonly unknown[] = []
-> = TOverride extends [infer Override, ...infer Rest extends unknown[]]
-  ? If<
-    IsUndefined<Override>,
-    MergeTuplesAcc<AfterFirst<TDefault>, Rest, TKey, [...TResults, First<TDefault>]>,
-    MergeTuplesAcc<AfterFirst<TDefault>, Rest, TKey, [...TResults, Override]>
-  >
-  : readonly [...TResults, ...TDefault];
-
-/**
- * **MergeTuples**
- *
- * Merges two tuple arrays by position in the tuple:
- *
- * - if `TOverride` is longer than `TDefault` then no defaults will be provided
- * - if `TDefault` is longer than `TOverride` then `TDefault` will be extended
- */
-export type MergeTuples<
-  TDefault extends readonly Narrowable[],
-  TOverride extends readonly Narrowable[],
-  TKey extends string | false = false // TODO: not currently being used
-> = MergeTuplesAcc<[...TDefault], [...TOverride], TKey>;
-
-
-type Process<
-TDefault,
-TOverride
-> = And<[
-  DoesExtend<TDefault, Dictionary|Nothing>, DoesExtend<TOverride, Dictionary|Nothing>
-]> extends true
-? MergeObjects<AsDictionary<TDefault>,AsDictionary<TOverride> >
-: And<[
-    DoesExtend<TDefault, Scalar|undefined>, DoesExtend<TOverride, Scalar|undefined>
-  ]> extends true
-  ? MergeScalars<TDefault & Scalar, TOverride & Scalar>
-  :
-    And<[
-      DoesExtend<TDefault, readonly Narrowable[]>,
-      DoesExtend<TOverride, readonly Narrowable[]>
-    ]> extends true
-    ? MergeTuples<TDefault & readonly Narrowable[], TOverride & readonly Narrowable[]>
-    : never;
-
-
-/**
- * **Merge**`<TDefault,TOverride>`
- *
- * A type utility that will merge any two like values together.
- *
- * **Related:** `MergeObjects`, `MergeScalars`, `MergeTuples`
- */
-export type Merge<
-  TDefault,
-  TOverride,
-> = AreSameType<TDefault,TOverride> extends true
-? Process<TDefault,TOverride>
-: Or<[
-    IsNothing<TDefault>, IsNothing<TOverride>
-  ]> extends true
-    ? And<[IsNothing<TDefault>, IsNothing<TOverride>]> extends true
-      ? Throw<
-          "invalid-merge",
-          `Merge<TDef,TOver> received two empty values; at least one needs to have a value!`,
-          "Merge",
-          { library: "inferred-types"; TDef: TDefault; TOver: TOverride }
-        >
-      : Process<TDefault, TOverride>
-    : Throw<
-      "invalid-merge",
-      `the Merge<TDef,TOver> utility can merge various types but both types must be of the same base type and they were not!`,
-      "Merge",
-      { library: "inferred-types"; TDef: TDefault; TOver: TOverride}
-    >;
-

package/src/types/type-conversion/MergeObjects.ts

@@ -1,56 +0,0 @@
-import {
-  AfterFirst,
-  CombinedKeys,
-  ExpandRecursively,
-  First,
-  IsDefined,
-  Dictionary,
-  ObjectKey,
-  Nothing,
-  IsNothing,
-  EmptyObject,
-  If,
-  As
-} from "inferred-types/dist/types/index";
-
-type Process<
-  TKeys extends readonly unknown[],
-  TDef extends Dictionary,
-  TOverride extends Dictionary,
-  TResult extends Dictionary = EmptyObject
-> = [] extends TKeys
-  ? ExpandRecursively<TResult>
-  : Process<
-    AfterFirst<TKeys>,
-    TDef,
-    TOverride,
-    First<TKeys> extends keyof TOverride
-    ? IsDefined<TOverride[First<TKeys>]> extends true
-    ? TResult & Record<First<TKeys>, TOverride[First<TKeys>]>
-    : First<TKeys> extends keyof TDef
-    ? TResult & Record<First<TKeys>, TDef[First<TKeys>]>
-    : TResult & Record<First<TKeys>, undefined>
-    : First<TKeys> extends keyof TDef
-    ? TResult & Record<First<TKeys>, TDef[First<TKeys>]>
-    : First<TKeys> extends ObjectKey
-    ? TResult & Record<First<TKeys>, undefined>
-    : never
-  >;
-
-/**
- * **MergeObjects**`<TDefault,TOverride>`
- *
- * A type utility that _shallowly merges_ two object types.
- */
-export type MergeObjects<
-  TDef extends Dictionary | Nothing,
-  TOverride extends Dictionary | Nothing,
-> = Process<
-  CombinedKeys<
-    As<If<IsNothing<TDef>, EmptyObject, TDef>, Dictionary>,
-    As<If<IsNothing<TOverride>, EmptyObject, TOverride>, Dictionary>
-  >,
-  As<If<IsNothing<TDef>, EmptyObject, TDef>, Dictionary>,
-  As<If<IsNothing<TOverride>, EmptyObject, TOverride>, Dictionary>
->;
-

package/src/types/type-conversion/Mutable.ts

@@ -1,46 +0,0 @@
-import {  Dictionary, IsObjectLiteral, IsTuple } from "inferred-types/dist/types/index";
-
-type MutableObject<T> = [T] extends [boolean]
-? T
-:{
-  -readonly [K in keyof T]: T[K] extends Dictionary
-    ? MutableObject<T[K]>
-    : IsTuple<T[K]> extends true
-      ? T[K]
-      : T[K] extends readonly (infer R)[]
-        ? R[]
-        : T[K];
-};
-
-type MutableArray<T extends readonly unknown[]> = [...{
-  // eslint-disable-next-line no-use-before-define
-  [K in keyof T]: Mutable<T[K]>
-}];
-
-
-/**
- * **Mutable**`<T>`
- *
- * Makes a readonly value to a mutable value without
- * widening the type.
- */
-export type Mutable<T> = [T] extends [readonly unknown[]]
-  ? MutableArray<T>
-  : [T] extends [boolean]
-    ? T
-    : [IsObjectLiteral<T>] extends [true] ? MutableObject<T> : T;
-
-
-
-/**
- * **Immutable**`<T>`
- *
- * Makes a _mutable_ value _immutable_.
- */
-export type Immutable<T extends { [propName:string]: unknown }> ={
-  readonly [key in keyof T]: T[key] extends { [propName:string]: unknown }
-    ? Immutable<T[key]>
-    : T[key]
-};
-
-

package/src/types/type-conversion/ObjectToKvDict.ts

@@ -1,21 +0,0 @@
-import {
-  AnyObject,
-} from "inferred-types/dist/types/index";
-
-
-/**
- * **ObjectToKv**`<TObj>`
- *
- * Type utility to convert an object to an array of object based key-value pairs.
- *
- * Example:
- * ```ts
- * // readonly [ {key: "foo", value: 1} ]
- * type T = ObjectToKv<{ foo: 1 }>
- * ```
- */
-export type ObjectToKvDict<
-  TObj extends AnyObject
-> = {
-  [K in keyof TObj]: {key: K; value: TObj[K]}
-};

package/src/types/type-conversion/ReduceValues.ts

@@ -1,32 +0,0 @@
-import {  AfterFirst, Dictionary, First, TypedFunction, Values } from "inferred-types/dist/types/index";
-
-
-type ProcessTuple<
-  TArray extends readonly unknown[] | unknown[],
-  TResults extends readonly unknown[] = []
-> = //
-  [] extends TArray
-    ? TResults
-    : First<TArray> extends TypedFunction
-      ? ProcessTuple<AfterFirst<TArray>, [...TResults, ReturnType<First<TArray>>]>
-      : ProcessTuple<AfterFirst<TArray>, [...TResults, First<TArray>]>;
-/**
- * **ReduceValues**`<TContainer>`
- *
- * Reduces a container to it's _values_ where if it's a function then the
- *  ReturnType` is returned, if not a function than just it's normal value.
- *
- * ```ts
- * // [true, "blue"]
- * type T = ReduceValues<[true, false, () => true, () => "blue"]
- * ```
- *
- * **Related:** `ReturnValues`, `Values`
- */
-export type ReduceValues<
-  TContainer extends readonly unknown[] | Dictionary,
-> = TContainer extends readonly unknown[]
-? ProcessTuple<TContainer>
-: TContainer extends Dictionary
-  ? ProcessTuple<Values<TContainer>>
-  : never

package/src/types/type-conversion/RemoveFromEnd.ts

@@ -1,14 +0,0 @@
-
-/**
- * **RemoveFromEnd**`<TContent,TRemove>`
- * 
- * Type utility which removes selected text -- `TRemove` -- from the end of `TContent`.
- * 
- * Note: if `TRemove` is not found then `TContent is left unchanged
- */
-export type RemoveFromEnd<
-  TContent extends string, 
-  TRemove extends string
-> = TContent extends `${infer Start}${TRemove}`
-  ? Start
-  : TContent;

package/src/types/type-conversion/RemoveFromStart.ts

@@ -1,14 +0,0 @@
-
-/**
- * **RemoveFromStart**`<TContent,TRemove>`
- * 
- * Type utility which removes selected text -- `TRemove` -- from the beginning of `TContent`.
- * 
- * Note: if `TRemove` is not found then `TContent is left unchanged
- */
-export type RemoveFromStart<
-  TContent extends string, 
-  TRemove extends string
-> = TContent extends `${TRemove}${infer Rest}`
-  ? Rest
-  : TContent;

package/src/types/type-conversion/RemoveIndex.ts

@@ -1,27 +0,0 @@
- 
-
-
-/**
- * **RemoveIndex**`<T>`
- * 
- * Removes an index like below while retaining other key/value pairs.
- * ```ts
- * interface Foo {
- *    foo: string;
- *    [key: string]: any;
- * }
- * // { foo: string }
- * type T = RemoveIndex<Foo>;
- * ```
- */
-export type RemoveIndex<T extends Record<any, any>> = {
-  [ 
-    P in keyof T as string extends P 
-      ? never 
-      : number extends P 
-      ? never 
-      : symbol extends P
-      ? never
-      : P 
-  ] : T[P]
-};

package/src/types/type-conversion/Replace.ts

@@ -1,28 +0,0 @@
-import { If } from "../boolean-logic/branching/If"
-import { IsEqual } from "../boolean-logic/operators/IsEqual"
-
-/**
- * **Replace**`<TText,TFind,TReplace>`
- *
- * Type utility which takes a string `TText` and finds the first instance of
- * `TFind` and replaces it with `TReplace`.
- *
- * ```ts
- * const fooy = "fooy";
- * // "Foo"
- * type Foo = Replace<typeof fooy, "y", "">;
- * ```
- *
- * **Related:** `ReplaceAll`
- */
-export type Replace<
-  TText extends string,
-  TFind extends string,
-  TReplace extends string
-> = TText extends ""
-  ? If<IsEqual<TFind, "">, TReplace, "">
-  : TFind extends ""
-    ? TText
-    : TText extends `${infer F}${TFind}${infer E}`
-    ? `${F}${TReplace}${E}`
-    : TText;

package/src/types/type-conversion/ReplaceAll.ts

@@ -1,87 +0,0 @@
-import {  AfterFirst, First, IsLiteral, IsStringLiteral, IsUnion, UnionToTuple } from "inferred-types/dist/types/index";
-import { Replace } from "./Replace";
-
-
-type Process<
-  TText extends string,
-  TFind extends string,
-  TReplace extends string
-> = Replace<TText,TFind,TReplace> extends `${string}${TFind}${string}`
-? Process<
-    Replace<TText,TFind,TReplace>,
-    TFind,
-    TReplace
-  >
-: Replace<TText,TFind,TReplace>
-
-type Iterate<
-  TText extends string,
-  TFind extends readonly string[],
-  TReplace extends string
-> = [] extends TFind
-? TText
-: Iterate<
-      Process<TText,First<TFind>, TReplace>,
-      AfterFirst<TFind>,
-      TReplace
-  >;
-
-type Singular<
-  TText extends string,
-  TFind extends string,
-  TReplace extends string
-> = IsStringLiteral<TText> extends true
-  ? IsStringLiteral<TFind> extends true
-    ? IsUnion<TFind> extends true
-      ? UnionToTuple<TFind> extends readonly string[]
-        ? Iterate<TText,UnionToTuple<TFind>,TReplace>
-        : never
-      : Process<TText,TFind,TReplace>
-    : string
- : string;
-
- type Multiple<
-  TText extends readonly string[],
-  TFind extends string,
-  TReplace extends string,
-  TResult extends readonly string[] = []
-> = [] extends TText
-? TResult
-: Multiple<
-    AfterFirst<TText>,
-    TFind,
-    TReplace,
-    [
-      ...TResult,
-      ReplaceAll<First<TText>,TFind,TReplace>
-    ]
-  >;
-
-/**
- * **ReplaceAll**`<TText,TFind,TReplace>`
- *
- * Type utility which takes a string `TText` and finds _all_ instances of
- * `TFind` and replaces it with `TReplace`.
- *
- * ```ts
- * const fooy = "fooy, Joey";
- * // "foo, Joe"
- * type Foo = ReplaceAll<typeof fooy, "y", "">;
- * ```
- *
- * **Related:** `Replace`
- *
- * - **Note:** this utility has been upgraded to take either a _string_ or a
- * _tuple_ of strings for `TText`.
- */
-export type ReplaceAll<
-  TText extends string | readonly string[],
-  TFind extends string,
-  TReplace extends string
-> = TText extends readonly string[]
-? IsLiteral<TText> extends true
-  ? Multiple<TText,TFind,TReplace>
-  : string[]
-: TText extends string
-? Singular<TText,TFind,TReplace>
-: never;

package/src/types/type-conversion/RetainChars.ts

@@ -1,35 +0,0 @@
-import { Constant } from "inferred-types/dist/constants/index";
-import {
-  IsWideType,
-  Or,
-  RemoveMarked,
-  Chars,
-  Join
-} from "inferred-types/dist/types/index";
-
-type Process<
-  TChars extends readonly string[],
-  TRetain extends string
-> = RemoveMarked<{
-  [K in keyof TChars]: TChars[K] extends TRetain
-    ? TChars[K]
-    : Constant<"Marked">
-}>;
-
-
-/**
- * **RetainChars**`<TContent,TRetain>`
- *
- * Converts a string `TContent` into a string with all
- * of the characters in `TRetain` _retained_ while all
- * other characters are removed.
- */
-export type RetainChars<
-  TContent extends string,
-  TRetain extends string,
-> = Or<[IsWideType<TContent>, IsWideType<TRetain>]> extends true
-  ? string
-  : Process<Chars<TContent>, TRetain> extends readonly string[]
-    ? Join<Process<Chars<TContent>, TRetain>>
-    : never;
-

package/src/types/type-conversion/ReturnValues.ts

@@ -1,31 +0,0 @@
-import {  AfterFirst, Dictionary, First, TypedFunction, Values } from "inferred-types/dist/types/index";
-
-
-type ProcessTuple<
-  TArray extends readonly unknown[] | unknown[],
-  TResults extends readonly unknown[] = []
-> = //
-  [] extends TArray
-    ? TResults
-    : First<TArray> extends TypedFunction
-      ? ProcessTuple<AfterFirst<TArray>, [...TResults, ReturnType<First<TArray>>]>
-      : ProcessTuple<AfterFirst<TArray>, TResults>;
-/**
- * **ReturnValues**`<TContainer>`
- *
- * Reduces a container's values down to just the return type of the
- * functions.
- * ```ts
- * // [true, "blue"]
- * type T = ReturnValues<[true, false, () => true, () => "blue"]
- * ```
- *
- * **Related:** `ReduceValues`
- */
-export type ReturnValues<
-  TContainer extends readonly unknown[] | Dictionary,
-> = TContainer extends readonly unknown[]
-? ProcessTuple<TContainer>
-: TContainer extends Dictionary
-  ? ProcessTuple<Values<TContainer>>
-  : never

package/src/types/type-conversion/RightWhitespace.ts

@@ -1,13 +0,0 @@
-import { Replace } from "./Replace";
-import { TrimRight } from "./TrimRight";
-
-/**
- * Provides the _left_ whitespace of a string
- * ```ts
- * // "\n\t "
- * type T = LeftWhitespace<"\n\t foobar">;
- * ```
- */
-export type RightWhitespace<S extends string> = string extends S
-  ? string
-  : Replace<S, TrimRight<S>, "">;

package/src/types/type-conversion/StringLength.ts

@@ -1,34 +0,0 @@
-/**
- * Type utility that provides the _length_ of a given string type in a way which
- * is _not_ limited to TS's recursive string length of roughly 48.
- * 
- * ```ts
- * // 3
- * type Three = StringLength<"foo">;
- * ```
- */
-export type StringLength<S extends string, R extends number[] = []>
-  = S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer _Seventh}${infer _Eighth}${infer _Ninth}${infer _Tenth}${infer Rest}`
-  ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]>
-  : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer _Seventh}${infer _Eighth}${infer _Ninth}${infer Rest}`
-  ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1, 1, 1, 1]>
-  : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer _Seventh}${infer _Eighth}${infer Rest}`
-  ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1, 1, 1]>
-  : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer _Seventh}${infer Rest}`
-  ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1, 1]>
-  : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}${infer _Sixth}${infer Rest}`
-  ? StringLength<Rest, [...R, 1, 1, 1, 1, 1, 1]>
-  : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer _Fifth}}${infer Rest}`
-  ? StringLength<Rest, [...R, 1, 1, 1, 1, 1]>
-  : S extends `${infer _First}${infer _Second}${infer _Third}${infer _Fourth}${infer Rest}`
-  ? StringLength<Rest, [...R, 1, 1, 1, 1]>
-  : S extends `${infer _First}${infer _Second}${infer _Third}${infer Rest}`
-  ? StringLength<Rest, [...R, 1, 1, 1]>
-  : S extends `${infer _First}${infer _Second}${infer Rest}`
-  ? StringLength<Rest, [...R, 1, 1]>
-  : S extends `${infer _First}${infer Rest}`
-  ? StringLength<Rest, [...R, 1]>
-  : [...R]["length"];
-
-
-

package/src/types/type-conversion/StringLiteralFromTuple.ts

@@ -1,38 +0,0 @@
-import { AfterFirst, First, IsNumericLiteral, IsStringLiteral } from "inferred-types/dist/types/index";
-
-type LitString<
-  TItems extends readonly unknown[],
-  TLiteral extends string = ""
-> = [] extends TItems
-? TLiteral
-: LitString<
-    AfterFirst<TItems>,
-    First<TItems> extends string
-      ? IsStringLiteral<First<TItems>> extends true
-        ? `${TLiteral}${First<TItems>}`
-        : `${TLiteral}${string}`
-    : First<TItems> extends number
-      ? IsNumericLiteral<First<TItems>> extends true
-        ? `${TLiteral}${First<TItems>}`
-        : `${TLiteral}${number}`
-      : TLiteral
-  >
-
-
-/**
- * **StringLiteralFromTuple**`<T>`
- *
- * Receives a tuple and creates a string literal type based
- * on the sequence of elements in the tuple.
- *
- * ```ts
- * // `${string}(${number})${string}`
- * type Lit=StringLiteralFromTuple<[
- *  string, "(", number, ")", string
- * ]>;
- * ```
- */
-export type StringLiteralFromTuple<
-  T extends readonly unknown[]
-> = LitString<T>;
-

package/src/types/type-conversion/StripChars.ts

@@ -1,44 +0,0 @@
-import {  Marked } from "inferred-types/dist/constants/index";
-import {
-  IsWideType,
-  Or,
-  RemoveMarked,
-  Chars,
-  As,
-  Concat
-} from "inferred-types/dist/types/index";
-
-type Strip<
-  TChars extends readonly string[],
-  TStrip extends string
-> = {
-  [K in keyof TChars]: TChars[K] extends TStrip
-    ? Marked
-    : TChars[K]
-};
-
-
-type Process<
-  TChars extends readonly string[],
-  TStrip extends string,
-> = As<RemoveMarked<Strip<TChars,TStrip>>, readonly string[]>;
-
-
-/**
- * **StripChars**`<TContent,TStrip>`
- *
- * Converts a string `TContent` into a string with all
- * of the characters in `TStrip` removed.
- *
- * - `TStrip` must be a single character or a union
- * of single characters or this will throw
- * `ErrorCondition<"invalid-strip-char">`
- */
-export type StripChars<
-  TContent extends string,
-  TStrip extends string,
-> = Or<[IsWideType<TContent>, IsWideType<TStrip>]> extends true
-  ? string
-  : // both TContent and TStrip are literals
-    Concat<Process<Chars<TContent>, TStrip>>;
-