inferred-types 0.51.1 → 0.51.3

package/src/types/base-types/functional/LeftRight.ts

@@ -1,251 +0,0 @@
-import { AsError, Concat, Contains, IfEqual, Defined, Tuple, NarrowlyContains } from "inferred-types/dist/types/index";
-
-type left = 1;
-type right = 2;
-
-/**
- * **LeftRight**`<L,R>`
- *
- * A tuple which has two possible states represented as `L`
- * and `R`.
- *
- * **Related:** `AsLeft`, `AsRight`, `WhereLeft`, `HandleRight`, `LeftExtends`, ...
- */
-export type LeftRight<
-  L = unknown,
-  R = unknown
-> = [kind: "LeftRight", left: L, right: R];
-
-/**
- * **AsLeftRight**`<A,B>`
- *
- * Assigns two types into a `LeftRight` tuple.
- *
- * Note: in most cases you should prefer the use of `ToLeft` and `ToRight`
- * but in the case where both sides of the `LeftRight` tuple are being leveraged
- * this is a convenient way to set the value.
- */
-export type AsLeftRight<A,B> = LeftRight<A,B>;
-
-/**
- * **IsSingleSided**`<T>`
- *
- * Boolean utility which tests whether a `LeftRight` container has
- * a value only on the left or right sides but _not_ both.
- */
-export type IsSingleSided<T extends LeftRight> = T extends [Defined, undefined]
-? true
-: T extends [undefined, Defined]
-  ? true
-  : false;
-
-/**
- * **AsLeft**`<T>`
- *
- * Creates a `LeftRight` tuple with value on left.
- */
-export type AsLeft<T> = LeftRight<T,null>;
-
-
-/**
- * **IfLeft**`<T>`
- *
- * Checks that
- */
-export type IfLeft<T extends LeftRight> = IsSingleSided<T> extends true
-? T[left] extends Defined ? true : false
-: never;
-
-/**
- * **AsRight**`<T>`
- *
- * Creates a `LeftRight` tuple with value on right.
- */
-export type AsRight<T> = LeftRight<null, T>;
-
-/**
- * **AppendRight**`<TErr, TExisting>`
- *
- * Type utility to add to the right side of a `LeftRight` tuple.
- *
- * - if the right of `TExisting` is empty it will add `TErr` as the first element
- * of an array
- */
-export type AppendRight<TErr, TExisting extends LeftRight> = TExisting[right] extends Tuple
-? [...TExisting[right], TErr] : [TErr];
-
-/**
- * **LeftExtends**`<TEval,TLeftRight>`
- *
- * Boolean utility which states whether the value of `TEval` _extends_
- * the _left_ value of `TLeftRight`
- */
-export type LeftExtends<
-  TEval,
-  TLeftRight extends LeftRight
-> = TEval extends TLeftRight[left] ? true : false;
-
-/**
- * **LeftEquals**`<TEval,TLeftRight>`
- *
- * Boolean utility which states whether the value of `TEval` _equals_
- * the _left_ value of `TLeftRight`
- */
-export type LeftEquals<
-  TEval,
-  TLeftRight extends LeftRight
-> = IfEqual<TEval, TLeftRight[left], true, false>;
-
-/**
- * **LeftIncludes**
- *
- * Boolean utility which validates that at least one of the strings segments
- * in `TEval` -- a string or tuple of strings -- is found in the string
- * value contained in the left side of `TLeftRight`.
- */
-export type LeftIncludes<
-  TEval,
-  TLeftRight extends LeftRight
-> = TLeftRight[left] extends string
-? TEval extends string | readonly string[]
-    ? Contains<TEval,TLeftRight[left]>
-    : false
-: false;
-
-type Explicitness = "loose" | "tight";
-
-/**
- * **LeftContains**
- *
- * Boolean utility which validates that the _left_ value of the `TLeftRight`
- * is a tuple and one of the elements _contains_ `TEval`.
- *
- * The definition of _contains_ is determined by the optional `TExplicitness` generic:
- * - it defaults to "loose" and in turns means that `TEval` must _extend_ an element
- * - if set to `tight` then it will perform an explicit equality
- * check on each element.
- *
- * **Related:** `LeftIncludes`
- */
-export type LeftContains<
-  TEval,
-  TLeftRight extends LeftRight,
-  TExplicitness extends Explicitness = "loose"
-> = TLeftRight[left] extends Tuple
-? TExplicitness extends "loose"
-  ? Contains<TLeftRight[left], TEval>
-  : NarrowlyContains<TLeftRight[left], TEval>
-: false;
-
-
-/**
- * **LeftExtends**`<TEval,TLeftRight>`
- *
- * Boolean utility which states whether the value of `TEval` _extends_
- * the _right_ value of `TLeftRight`
- */
-export type RightExtends<
-  TEval,
-  TLeftRight extends LeftRight
-> = TEval extends TLeftRight[right] ? true : false;
-
-/**
- * **RightEquals**`<TEval,TLeftRight>`
- *
- * Boolean utility which states whether the value of `TEval` _equals_
- * the _right_ value of `TLeftRight`
- */
-export type RightEquals<
-  TEval,
-  TLeftRight extends LeftRight
-> = IfEqual<TEval, TLeftRight[right], true, false>;
-
-
-/**
- * **RightIncludes**
- *
- * Boolean utility which validates that at least one of the strings segments
- * in `TEval` -- a string or tuple of strings -- is found in the string
- * value contained in the right side of `TLeftRight`.
- *
- * **Related:** `RightContains`
- */
-export type RightIncludes<
-  TEval,
-  TLeftRight extends LeftRight
-> = TLeftRight[right] extends string
-? TEval extends string | readonly string[]
-  ? Contains<TEval,TLeftRight[right]>
-  : false
-: false;
-
-/**
- * **RightContains**
- *
- * Boolean utility which validates that the _right_ value of the `TLeftRight`
- * is a tuple and one of the elements _contains_ `TEval`.
- *
- * The definition of _contains_ is determined by the optional `TExplicitness` generic:
- * - it defaults to `loose` and in turns means that `TEval` must _extend_ an element
- * - if set to `tight` then it will perform an explicit equality
- * check.
- *
- * **Related:** `RightIncludes`
- */
-export type RightContains<
-  TEval,
-  TLeftRight extends LeftRight,
-  TExplicitness extends Explicitness = "loose"
-> = TLeftRight[left] extends Tuple
-? TExplicitness extends "loose"
-  ? Contains<TLeftRight[left], TEval>
-  : NarrowlyContains<TLeftRight[left], TEval>
-: false;
-
-export type LeftRight__Operations =
-| "extends"
-| "equals"
-| "includes"
-| "contains";
-
-
-/**
- * **WhereLeft**`<TEval,TOp,TLeftRight,[IF],[ELSE]>`
- *
- * A branching utility which branches based on:
- *  - some type `TEval` when using some operation `TOp`
- *  - evaluates to `true` for `TLeftRight[left]`
- *
- * #### Operations
- * - operations are _extends_, _equals_, _includes_, and _contains_
- * - _includes_ looks for sub-strings, whereas _contains_ looks for an element of a tuple
- *
- * #### Defaults
- * - the `IF` type defaults to either `TEval` or -- where possible -- a narrowed version based on the intersection of the two types
- * - the `ELSE` defaults to `ErrorCondition<"conditional-failure">`
- */
-export type WhereLeft<
-  TEval,
-  TOp extends LeftRight__Operations,
-  TLeftRight extends LeftRight,
-  IF = TEval & TLeftRight[left],
-  ELSE = AsError<[
-    "conditional-failure-left",
-    Concat<[
-      "While using the '",
-      TOp,
-      "' operation to compare to the LEFT value"
-    ]>,
-    { library: "inferred-types"; utility: "IfLeft" }
-  ]>
-> =
-TOp extends "extends"
-  ? LeftExtends<TEval,TLeftRight> extends true ? IF : ELSE
-: TOp extends "equals"
-  ? LeftEquals<TEval, TLeftRight> extends true ? IF : ELSE
-: TOp extends "includes"
-  ? LeftIncludes<TEval, TLeftRight> extends true ? IF : ELSE
-: TOp extends "contains"
-  ? LeftContains<TEval, TLeftRight> extends true ? IF : ELSE
-: never;
-

package/src/types/base-types/functional/index.ts

@@ -1 +0,0 @@
-export * from "./LeftRight";

package/src/types/base-types/index.ts

@@ -1,27 +0,0 @@
-
-export * from "./Defined";
-export * from "./Something";
-export * from "./Nothing";
-export * from "./NotNull";
-export * from "./AnyObject";
-export * from "./IndexableObject";
-export * from "./EmptyObject";
-export * from "./AnyArray";
-export * from "./Scalar";
-export * from "./ScalarNotSymbol";
-export * from "./Container";
-export * from "./Tuple";
-export * from "./Thenable";
-export * from "./NumericSign";
-export * from "./Digital";
-export * from "./Indexable";
-export * from "./FalsyValue";
-export * from "./ObjectKey";
-export * from "./NarrowObject";
-export * from "./Dictionary";
-export * from "./NonArray";
-export * from "./List";
-export * from "./LikeRegExp";
-
-export * from "./fns/index";
-export * from "./functional/index";

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

@@ -1,4 +0,0 @@
-/**
- * Expresses the _type_ of logical combinator being used
- */
-export type LogicalCombinator = "AND" | "OR";

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

@@ -1,18 +0,0 @@
-import { Something } from "inferred-types/dist/types/index";
-
-type Process<TVal,TDefault> = TVal extends Something
-? TVal
-: TDefault;
-
-
-
-/**
- * **Default**`<TVal,TDefault,[TProtect]>`
- *
- * Branching operator which allows giving a value `TVal` a _default value_ when
- * it's value is either `null` or `undefined`.
- */
-export type Default<
-  TVal,
-  TDefault,
-> = Process<TVal, TDefault>;

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

@@ -1,38 +0,0 @@
-import { Tuple } from "inferred-types/dist/types/index";
-import { Or } from "../combinators";
-import { IsFalse, IsNever } from "../operators";
-
-
-type ShouldFail<TTest> = [IsNever<TTest>] extends [true]
-? true
-: [IsFalse<TTest>] extends [true]
-? true
-: false;
-
-type Iterate<
-  TTest extends readonly unknown[]
-> = Or<{
-  [K in keyof TTest]: ShouldFail<[TTest[K]]>
-}>
-
-/**
- * **Fail**`<TVal, TTest>`
- *
- * A branching utility which tests `TTest` for `false`, `never`, or `ErrorCondition`
- * and if matched will set the value to `never`. If there is _not_ a match then
- * `TVal` will be passed through.
- *
- * If you wish to have more than one test which might produce the failure
- * condition you can pass in a tuple of tests into `TTest` and if _any_ of
- * the tests fail then the condition fails.
- */
-export type Fail<
-  TVal,
-  TTest
-> = [TTest] extends [Tuple]
-? [Iterate<TTest>] extends [true]
-  ? never
-  : TVal
-: [ShouldFail<TTest>] extends [true]
-  ? never
-  : TVal;

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

@@ -1,52 +0,0 @@
-import {
-  IsEqual,
-  Filter,
-  If,
-  IsUnion,
-  TupleToUnion,
-  UnionToTuple
-} from "inferred-types/dist/types/index";
-
-type Narrow<
-  TContent,
-  THandle
-> = IsUnion<TContent> extends true
-  ? UnionToTuple<TContent> extends readonly unknown[]
-    ? Filter<UnionToTuple<TContent>, THandle> extends readonly unknown[]
-      ? TupleToUnion<Filter<UnionToTuple<TContent>, THandle>>
-      : never
-  : never
-: TContent;
-
-
-/**
- * **Handle**`<TContent,THandle,TMapTo,[TSpecificity]>`
- *
- * Maps `TContent` when it _extends_ / _equals (based on `TSpecificity`) the type
- * of `THandle` to `TMapTo`, otherwise it just proxies the value through.
- *
- * - `TSpecificity` defaults to _extends_ but can be set to _equals_
- *
- * **Related:** `THandle`
- */
-export type Handle<
-  TContent,
-  THandle,
-  TMapTo,
-  TSpecificity extends "extends" | "equals" = "extends"
-> =
-[THandle] extends never[]
-  ? [TContent] extends never[]
-    ? TMapTo
-    : TContent
-: TSpecificity extends "extends"
-  ? [TContent] extends [THandle]
-    ? TMapTo
-    : Narrow<TContent,THandle>
-  : If<
-    IsEqual<[TContent], [THandle]>,
-    TMapTo,
-    TContent
-  >
-
-

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

@@ -1,45 +0,0 @@
-import {
-  ErrorCondition,
-  IsBoolean,
-  IsBooleanLiteral,
-  IsFalse,
-  IsNever,
-  IsTrue,
-  LogicFunction
-} from "inferred-types/dist/types/index";
-
-
-
-
-
-/**
- * **If**`<TTest,[TIf],[TElse],[TMaybe]>`
- *
- * Branching utility which tests `TTest` for a boolean value.
- */
-export type If<
-  TTest,
-  TIf = true,
-  TElse = false,
-  TMaybe = TIf | TElse,
-  TNever = never,
-  TError = never
-> =  [IsNever<TTest>] extends [true]
-? TNever
-: [TTest] extends [ErrorCondition]
-  ? TError
-: [TTest] extends [boolean]
-  ? [IsTrue<TTest>] extends [true]
-    ? TIf
-    : [IsBooleanLiteral<TTest>] extends [true]
-      ? TElse
-      : TMaybe
-  : [TTest] extends [LogicFunction]
-    ? [IsTrue<ReturnType<TTest>>] extends [true]
-      ? TIf
-    : [IsFalse<ReturnType<TTest>>] extends [true]
-      ? TElse
-      : [IsBoolean<ReturnType<TTest>>] extends [true]
-        ? TMaybe
-        : never
-    : never;

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

@@ -1,17 +0,0 @@
-import { AllExtend } from "inferred-types/dist/types/index";
-
-/**
- * **IfAllExtend**`<TList,TExtend,IF,ELSE>`
- *
- * Branching type util which returns `IF` if **all** of the elements in
- * `TList` extend `TExtend`.
- *
- * - this is an inverted branching util from `IfExtendsAll`
- * - a closer comparison is `IfSomeExtend` which requires all items to extend
- */
-export type IfAllExtend<
-  TList extends readonly unknown[],
-  TExtend,
-  IF,
-  ELSE
-> = AllExtend<TList,TExtend> extends true ? IF : ELSE;

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

@@ -1,13 +0,0 @@
-import { Tuple,AllLiteral } from "inferred-types/dist/types/index";
-
-
-/**
- * **IfAllLiteral**`<TTuple,IF,ELSE>`
- *
- * Branching utility which branches on whether the tuple passed in
- * has _literal_ values for every member.
- */
-export type IfAllLiteral<TTuple extends Tuple, IF, ELSE> =
-AllLiteral<TTuple> extends true
-  ? IF
-  : ELSE;

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

@@ -1,31 +0,0 @@
-import { IsEqual } from "inferred-types/dist/types/index";
-
-/**
- * **IfEqual**`<X,Y,[IF],[ELSE]>`
- *
- * Type utility which returns type `IF` _if_ `X` is equal to `Y`; otherwise returns
- * type `ELSE`.
- */
-export type IfEqual<
-  X,
-  Y,
-  IF = X & Y,
-  ELSE = Exclude<X,Y>
-> = IsEqual<X,Y> extends true
-  ? IF
-  : ELSE;
-
-/**
- * **IfEqual**`<X,Y,[IF],[ELSE]>`
- *
- * Type utility which returns type `IF` _if_ `X` is equal to `Y`; otherwise returns
- * type `ELSE`.
- *
- * **Note:** this is just a type alias for `IfEqual`
- */
-export type IfEquals<
-X,
-Y,
-IF = X & Y,
-ELSE = Exclude<X,Y>
-> = IfEqual<X,Y,IF,ELSE>;

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

@@ -1,20 +0,0 @@
-import { ErrorConditionShape, IsErrorCondition } from "inferred-types/dist/types/index";
-
-
-/**
- * **IFErrorCondition**`<T,IF,[ELSE]>`
- *
- * Branching utility which returns `IF` when `T` is an `ErrorCondition`, otherwise
- * it returns `ELSE`.
- *
- * **Related:** `IfError`
- */
-export type IfErrorCondition<
-  T,
-  IF,
-  ELSE = T
-> = IsErrorCondition<T> extends true
-  ? T extends ErrorConditionShape
-    ? IF
-    : never
-  : ELSE;

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

@@ -1,34 +0,0 @@
-import { Length, IfEqual, Tuple, If, IsStringLiteral,  IsNumericLiteral } from "inferred-types/dist/types/index";
-
-
-/**
- * **IfLength**`<TEvaluate,TLength,IF,[ELSE],[MAYBE]>`
- *
- * Type utility which returns type `IF` when `TEvaluate` evaluates to being
- * a length of `TLength`. It returns type `ELSE` if it can determine the length
- * at design time and otherwise returns `MAYBE`.
- *
- * - the `ELSE` type will default to `TEvaluate` by default
- * - the `MAYBE` type will default to `IF | ELSE` by default
- * - If a _non-array_ type is passed into `TEvaluate` then utility will result `ELSE`
- * type.
- */
-export type IfLength<
-  TEvaluate extends Tuple | string,
-  TLength extends number,
-  IF,
-  ELSE = TEvaluate,
-  MAYBE = IF | ELSE
-> = TEvaluate extends readonly unknown[]
-  ? IsNumericLiteral<TLength> extends true
-    ? IfEqual<Length<TEvaluate>, TLength, IF, ELSE>
-    : MAYBE
-  : TEvaluate extends unknown[]
-    ? MAYBE
-    : TEvaluate extends string
-      ? If<
-          IsStringLiteral<TEvaluate>,
-          IfEqual<Length<TEvaluate>, TLength, IF, ELSE>,
-          MAYBE
-        >
-      : MAYBE;

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

@@ -1,13 +0,0 @@
-import { IsNever } from "inferred-types/dist/types/index";
-
-/**
- * **IfNever**`<T,IsNever,NotNever>`
- *
- * Type utility which transforms type `T` based on whether it extends the _never_
- * type.
- */
-export type IfNever<
-  T,
-  IF,
-  ELSE = T
-> = [IsNever<T>] extends [true] ? IF : ELSE;

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

@@ -1,32 +0,0 @@
-import {
-  IsUndefined,
-  Unset
-} from "inferred-types/dist/types/index";
-
-
-/**
- * **IfUnset**`<TTest,TElse,[TIf]>`
- *
- * Branching utility which will proxy _any_ type through except
- * for those set with `Unset<[T]>`.
- *
- * When `Unset` is found then it will be replaced with `TElse`.
- */
-export type IfUnset<
-  TTest,
-  TElse,
-  TIf = TTest
-> = TTest extends Unset
-? TElse
-: Exclude<TIf, Unset>;
-
-
-export type IfUnsetOrUndefined<
-TTest,
-TElse,
-TIf = TTest
-> = TTest extends Unset
-? TElse
-: IsUndefined<TTest> extends true
-? TElse
-: Exclude<TIf, Unset | undefined>;

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

@@ -1,55 +0,0 @@
-/* eslint-disable no-use-before-define */
-import { AfterFirst, AsArray, Container, First, IndexOf, NonArray, Nothing, Throw } from "inferred-types/dist/types/index";
-
-type ProcessContainers<
-  TValues extends readonly (Container | TIgnore)[],
-  TIgnore,
-  TOffset extends PropertyKey | null,
-  TNotFound
-> = [] extends TValues
-? TNotFound
-: IndexOf<First<TValues>, TOffset, TIgnore> extends TIgnore
-  ? ProcessContainers<AfterFirst<TValues>, TIgnore,TOffset,TNotFound>
-  : IndexOf<First<TValues>, TOffset>;
-
-type Process<
-  TValues extends readonly unknown[],
-  TIgnore,
-  TNotFound
-> = [] extends TValues
-? TNotFound
-: First<TValues> extends TIgnore
-  ? Process<AfterFirst<TValues>,TIgnore,TNotFound>
-  : First<TValues>;
-
-/**
- * **Iff**`<TValues,[TIgnore],[TOffset],[TNotFound]>`
- *
- * Looks through a list of values -- `TValues` -- until it finds
- * the first one which _does not_ extend `TIgnore` (which is by
- * default set to null or undefined).
- *
- * If it reaches the end without finding a value to use it will
- * fall back on the `TNotFound` value which is `ErrorCondition<"not-found">`
- * by default.
- */
-export type Iff<
-  TValues extends NonArray | readonly unknown[],
-  TIgnore = Nothing,
-  TOffset extends PropertyKey | null = null,
-  TNotFound = Throw<
-    "not-found",
-    `Call to Iff utility resulted in no valid results`,
-    "Iff",
-    { library: "inferred-types"; values: AsArray<TValues> }
-  >
-> = TOffset extends PropertyKey
-? TValues extends readonly (Container | TIgnore)[]
-  ? ProcessContainers<AsArray<TValues>, TIgnore, TOffset, TNotFound>
-  : Throw<
-      "invalid-values",
-      `When calling Iff with a TOffset set; the TValues generic must contain a tuple of containers!`,
-      "Iff",
-      { library: "inferred-types"; values: AsArray<TValues>; offset: TOffset }
-    >
-: Process<AsArray<TValues>,TIgnore,TNotFound>;