inferred-types 0.51.1 → 0.51.2

package/src/types/functional/Result.ts

@@ -1,327 +0,0 @@
-import {
-  AsString,
-  TupleToUnion,
-  Widen,
-  KebabCase,
-  RuntimeUnion,
-  Narrowable,
-  TypeGuard,
-  StackTrace,
-  TakeProp,
-  DoesExtend,
-  If,
-  IsFunction,
-  Something,
-  IsEqual,
-  And
-} from "inferred-types/dist/types/index";
-
-import { RESULT } from "inferred-types/dist/constants/index";
-
-type OK = typeof RESULT.Ok;
-type ERR = typeof RESULT.Err;
-
-/**`
- * **ResultErr**
- *
- * A `ResultErr` provides the structure of an
- */
-export type ResultErr<
-  K extends string = string,
-  C extends Record<string, unknown> = Record<string, unknown>,
-  S extends boolean = boolean
-> = {
-  /**
-   * **kind**
-   *
-   * The _kind_ property in a `ResultErr` is used **categorize** an error
-   * and can be highly useful when people are attempting to recover from the
-   * error.
-   */
-  kind: KebabCase<K>;
-  /**
-   * **msg**
-   *
-   * The `msg` property allows developer to use _prose_ to describe the error.
-   * It is useful for people debugging an error as it may provide some additional
-   * summary insight into the error but it is typically not used programmatically
-   * to recover from an error.
-   */
-  msg: string;
-  /**
-   * **context**
-   *
-   * The `context` property is a dictionary of key/value pairs that allows for
-   * deeper context to be provided when an error is encountered.
-   */
-  context?: C;
-
-  /**
-   * **stack**
-   *
-   * Allows a user to express whether a stack trace should be generated for
-   * a given error.
-   */
-  stack?: S;
-}
-
-/**
- * **ResultErrInputs**
- *
- * The types which can _represent_ an error within an `Err` block.
- */
-export type ErrInput = string
-  | ResultErr
-  | ResultErr[]
-  | RuntimeUnion<ResultErr[]>;
-
-/**
- * **AsErr**`<T>`
- *
- * **Related:** `AsErrKind`, `ResultErr`
- */
-export type AsErr<T extends ErrInput> = TupleToUnion<
-T extends RuntimeUnion<ResultErr[]>
-  ? T["type"]
-  : T extends string
-  ? [{ msg: T; kind: KebabCase<T>; context: NonNullable<unknown>; stack: false }]
-  : T extends ResultErr
-  ? [{
-    kind: TakeProp<T, "kind", "undefined">;
-    msg: TakeProp<T, "msg", "undefined">;
-    context: TakeProp<T, "context", NonNullable<unknown>>;
-    stack: TakeProp<T, "stack", false>;
-  }]
-  : T extends readonly Required<ResultErr>[]
-  ? T
-  : never
->;;
-
-/**
- * **AsErrKind**
- *
- * Provides a useful way to build a `ResultErr` which will be used as a "template"
- * (aka., "msg" is always just a wide string value)
- *
- * **Related:** `AsErr`, `ResultErr`
- */
-export type AsErrKind<
-  T extends string | {  kind: string; context?: Record<string, unknown>; stack?: boolean },
-> = T extends string
-? {  kind: KebabCase<T>; msg: string; context: NonNullable<unknown>; stack: false }
-: T extends { kind: string; context: Record<string, unknown>; stack?: boolean }
-  ? {
-    kind: KebabCase<AsString<T["kind"]>>;
-    msg: string;
-    context: "context" extends keyof T
-      ? T["context"] extends Record<string, unknown>
-        ? Widen<T["context"]>
-        : NonNullable<unknown>
-      : NonNullable<unknown>;
-    stack: TakeProp<T, "stack", false>;
-  }
-  : never;
-
-
-/**
- * **ResultTuple**
- *
- * A tuple containing the types of both possible OK and ERR conditions and
- * are stored in the `__kind` property of a `Result<T,E>`.
- */
-export type ResultTuple<
-  T = unknown,
-  E extends ErrInput = ErrInput
-> = {
-  __kind: ["Result", ok: T, err: E];
-};
-
-
-export type RealizedErr<T extends ResultErr = ResultErr> = Exclude<T, "stack"> & {
-  stack: T["stack"] extends true ? StackTrace : never;
-};
-
-/**
- * **Err**`<E>`
- *
- * A type utility which receives a _representation_ of an error when using
- * the `Result<T,E>` structure. It will expand this _representation_ to a fully
- * formed **state** and **err** property.
- */
-export type Err<E extends ErrInput = ErrInput, T =unknown> = {
-  state: ERR;
-  err: AsErr<E>;
-} & ResultTuple<T,E>
-
-/**
- * **Ok**`<T>`
- *
- * The **ok** state of a `Result<T,E>` structure.
- */
-export type Ok<T = unknown, E extends ErrInput = ErrInput> = {
-  state: OK;
-  val: T;
-} & ResultTuple<T,E>;
-
-/**
- * **Result**`<T,E>`
- *
- * A structure which contains the union of either an OK or ERR
- * state. This is meant to resemble the **Rust** type of the same
- * name as much as possible.
- */
-export type Result<
-  T = unknown,
-  E extends ErrInput = ErrInput
-> = Ok<T,E> | Err<E,T>
-
-/**
- * **ErrFrom**`<T>`
- *
- * Extracts the `Err` type from a `Result<T,E>`.
- */
-export type ErrFrom<
-  TResult extends Result,
-> = TResult["__kind"][2]
-
-/**
- * **KindFrom**`<T>`
- *
- * Extracts the _kind_ property from the `Err` type of a `Result<T,E>`.
- */
-export type KindFrom<
-  TResult extends Result
-> = AsErr<TResult["__kind"][2]>["kind"];
-
-export type OkFrom<
-  TResult extends Result
-
-> = TResult["__kind"][1];
-
-type _IsResult<
-TTest extends Something,
-TVal = unknown,
-TErr extends ErrInput = ErrInput
-> = TTest extends Result
-? OkFrom<TTest> extends TVal
-  ? KindFrom<TTest> extends AsErr<TErr>["kind"]
-    ? true
-    : false
-  : false
-: false
-
-/**
- * **IsResult**`<TTest,[TOk],[TErr]>`
- *
- * Boolean utility which tests whether `TTest` qualifies as a `Result<T,E>` type.
- *
- * **Note:** you may include explicit `TOk` or `TErr` values if you want to narrow
- * the check condition but they are not required.
- */
-export type IsResult<
-  TTest extends Something,
-  TVal = unknown,
-  TErr extends ErrInput = ErrInput
-> = TTest extends ResultTuple
-? If<
-    IsEqual<_IsResult<TTest,TVal,TErr>, boolean>,
-      false,
-      _IsResult<TTest,TVal,TErr>
-    >
-: false;
-
-
-/**
- * **IsOk**`<TTest,[TVal]>`
- *
- * Boolean utility which detects whether `TTest` is in the "Ok" state
- * for a `Result<T,E>`.
- */
-export type IsOk<
-  TTest,
-  TVal = unknown
-> = TTest extends { state: OK; val: TVal } ? true : false;
-
-/**
- * **IsErr**`<TTest, [TErr]>`
- *
- * Boolean utility which detects whether `TTest` is in the "Err" state
- * for a `Result<T,E>`.
- */
-export type IsErr<
-  TTest,
-  TErr extends ErrInput = ErrInput
-> = If<
-      And<[
-        DoesExtend<TTest, { state: ERR }>,
-        TTest extends { err: {kind: string}}
-        ? AsErr<TErr> extends  { kind: string}
-          ? TTest["err"]["kind"] extends AsErr<TErr>["kind"]
-            ? true
-            : false
-          : true
-        : true
-      ]>,
-      true,
-      false
->
-
-export type ResultApi<
-  T,
-  E extends ErrInput = ErrInput
-> = {
-  kind: "Result API";
-  /**
-   * **Result<T,E>**
-   *
-   * the _type_ of the result created
-   */
-  result: Result<T,E>;
-  /**
-   * **ok**`<T>`(val: T) -> Ok`<T>`
-   *
-   * Allows a developer inside of a function with a `Result<T,E>`
-   * return type to express the "OK" variant in a type safe manner.
-   */
-  ok: <V extends T>(v: V) =>  Ok<V,E>;
-  /**
-   * **err**`<E>`(err: E) => Err`<E>`
-   *
-   * Allows a developer inside of a function with a `Result<T,E>`
-   * return type to express the "ERR" variant in a type safe manner.
-   */
-  err: <TErr extends E>(e: Err) => Err<TErr, T>;
-
-  /**
-   * **isOk**(val)
-   *
-   * A type guard which helps to _narrow_ a `Result` type into the `Ok` variant.
-   */
-  isOk: TypeGuard<Ok<T>, IsEqual<T, unknown> extends true ? Narrowable : T >;
-  /**
-   * **isErr**(val)
-   *
-   * A type guard which helps to _narrow_ a `Result` type into the `Err` variant.
-   */
-  isErr: TypeGuard<Err<AsErr<E>>,ErrInput>;
-
-  /**
-   * **okOrElse**(val, otherwise)
-   *
-   * Allows you to accept the `Ok` variant's value when it arrives but
-   * handle the `Err` variant with another value.
-   *
-   * The handler for the `Err` condition can be a static value or a function
-   * (which will receive the `Err` as it's input).
-   */
-  okOrElse: <V extends Result<T,E>, TElse>(v: V, otherwise: TElse) => V extends Ok<V>
-    ? Ok<V>
-    : If<IsFunction<TElse>>;
-  /**
-   * **okOrThrow**(val) -> Ok<T>["val"]
-   *
-   * A function which either returns the _value_ of the `Ok` variant or
-   * throws a JS error.
-   */
-  okOrThrow: <V extends Result<T,E>>(v: V) => Ok<V>["val"];
-}

package/src/types/functional/Right.ts

@@ -1,8 +0,0 @@
-import { LeftRight } from "inferred-types/dist/types/index";
-
-/**
- * **Right**<T>
- *
- * Extracts the **right** value from a `LeftRight`.
- */
-export type Right<T extends LeftRight> = T[2];

package/src/types/functional/index.ts

@@ -1,3 +0,0 @@
-export * from "./Left";
-export * from "./Right";
-export * from "./Result";

package/src/types/functions/AsFnMeta.ts

@@ -1,32 +0,0 @@
-
-
-import type {
-  AnyFunction,
-  FnMeta,
-  FnProps,
-  EmptyObject,
-  ExpandDictionary,
-  TypedFunction,
-  IsNonEmptyObject
-} from "inferred-types/dist/types/index";
-
-/**
- * **AsFnMeta**`<TFn>`
- *
- * Converts any function into `FnMeta` format.
- */
-export type AsFnMeta<
-  TFn extends AnyFunction
-> = TFn extends TypedFunction
-? [IsNonEmptyObject<FnProps<TFn>>] extends [true]
-  ? FnMeta<
-    TFn,
-    Parameters<TFn>,
-    ReturnType<TFn>,
-    ExpandDictionary<FnProps<TFn>>
-  >
-  : FnMeta<TFn,Parameters<TFn>, ReturnType<TFn>, EmptyObject>
-
-: FnMeta<TypedFunction, any[], any, EmptyObject>;
-
-type _x = FnMeta<TypedFunction,any[], any, EmptyObject>;

package/src/types/functions/FnFrom.ts

@@ -1,14 +0,0 @@
-import { Dictionary, EmptyObject, Tuple } from "inferred-types/dist/types/index";
-
-/**
- * **FnFrom**`<TParams,[TReturn],[TProps]>`
- *
- * Type utility  to build a type from it's constituent parts.
- */
-export type FnFrom<
-  TParams extends Tuple,
-  TReturn = unknown,
-  TProps extends Dictionary = EmptyObject
-> = TProps extends EmptyObject
-? <T extends TParams>(...args: T) => TReturn
-: (<T extends TParams>(...args: T) => TReturn) & TProps

package/src/types/functions/FnMeta.ts

@@ -1,36 +0,0 @@
-
-import {
-  AnyFunction,
-  Dictionary,
-  IsNarrowingFn,
-  IsNonEmptyObject
-} from "inferred-types/dist/types/index";
-
-
-
-
-/**
- * **FnMeta**<TArgs,TReturn,TProps>
- *
- * The meta-information around a given function. Represented as an
- * object with the following properties:
- *
- * 1. `args` - the array of arguments the function expects
- * 2. `returns` - the return type of the function
- * 3. `props` - any Key/Value props also packaged with the function, if no
- * key/values are found it will be set to `no-props`.
- */
-export type FnMeta<
-  TFn extends AnyFunction = AnyFunction,
-  TArgs extends readonly any[] = readonly any[],
-  TReturn = unknown,
-  TProps extends Dictionary = Dictionary,
-> = {
-  fn: TFn;
-  args: TArgs;
-  returns: TReturn;
-  props: TProps;
-  hasProps: [IsNonEmptyObject<TProps>] extends [true] ? true : false;
-  hasArgs: TArgs["length"] extends 0 ? false : true;
-  isNarrowingFn: IsNarrowingFn<TFn>;
-};

package/src/types/functions/FnProps.ts

@@ -1,26 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-function-type */
-import {
-  AnyFunction,
-  EmptyObject,
-  IsEqual,
-  ObjectKey
-} from "inferred-types/dist/types/index";
-
-type Process<
-  T extends AnyFunction
-> = IsEqual<T, Function> extends true
-? EmptyObject
-: keyof T extends ObjectKey
-    ? Pick<T, keyof T>
-    : never;
-
-/**
- * **FnProps**`<T>`
- *
- * Return a dictionary of key/value pairs from a function. If no key/value
- * pairs are assigned to the function base then an empty object is returned.
- */
-export type FnProps<
-  T extends AnyFunction
-> = Process<T>;
-

package/src/types/functions/FnWithDescription.ts

@@ -1,19 +0,0 @@
-import { AnyFunction, ObjectKey } from "../base-types";
-
-export type FnDefn = [fn: AnyFunction ]
-| [fn: AnyFunction, desc: string]
-| [fn: AnyFunction, props: Record<ObjectKey, unknown> ];
-
-/**
- * **Fn**`<TArgs,TReturn>`
- */
-export type FnWithDescription<
-  TFn extends FnDefn = FnDefn
-> = TFn extends [ fn: AnyFunction ]
-? TFn[0]
-: TFn extends [ fn: AnyFunction, desc: string]
-  ? TFn[0] & { desc: TFn[1] }
-  : TFn extends [ fn: AnyFunction, props: Record<ObjectKey, unknown> ]
-    ? TFn[0] & TFn[1]
-    : never;
-

package/src/types/functions/FnWithProps.ts

@@ -1,26 +0,0 @@
-import type {
-  AnyObject,
-  IsTrue,
-  If,
-  JustFunction,
-  TypedFunction
-} from "inferred-types/dist/types/index";
-
-
-
-/**
- * **FnWithProps**`<TFn,TProps,[TClone]>`
- *
- * Produces a function which is intersected with a dictionary of KV's.
- *
- * **Related**: `SimpleFn`, `NarrowableFn`, `AnyFunction`, `IsFunctionWithDict`
- */
-export type FnWithProps<
-  TFn extends TypedFunction,
-  TProps extends AnyObject,
-  TClone extends boolean | null | undefined = true
-> = If<
-  IsTrue<TClone>,
-  JustFunction<TFn> & TProps,
-  TFn & TProps
->;

package/src/types/functions/HandleDoneFn.ts

@@ -1,12 +0,0 @@
-import {  TypedFunction } from "../base-types";
-
-/**
- * **HandleDoneFn**`<T>`
- * 
- * A type utility which looks for a `done` property on `T` and
- * if it's a function it will convert the type to the _return type_
- * of the `done()` function.
- */
-export type HandleDoneFn<T> = T extends { done: TypedFunction }
-  ? ReturnType<T["done"]>
-  : T;

package/src/types/functions/IdentityFn.ts

@@ -1,20 +0,0 @@
-import { IsLiteral, IsUnion, Throw } from "inferred-types/dist/types/index";
-
-
-/**
- * **IdentityFn**`<TValue, [TNarrow]>`
- *
- * A function which returns the value of `T`.
- */
-export type IdentityFn<
-  TValue,
-  TNarrow extends boolean = false
-> = [TNarrow] extends [true]
-? [IsLiteral<TValue>] extends [true]
-  ? [IsUnion<TValue>] extends [true]
-    ? <T extends TValue>(v: T) => T
-    : Throw<"invalid-literal", `A narrowing identity function must be based off a wide type or a union of literals!`, "IdentityFn", { value: TValue }>
-  : <T extends TValue>(v: T) => T
-: () => TValue;
-
-

package/src/types/functions/LiteralFn.ts

@@ -1,53 +0,0 @@
-import {
-  AnyFunction,
-  AsFnMeta,
-  Dictionary,
-  EmptyObject,
-  IsEqual,
-  IsNonEmptyObject,
-  Tuple
-} from "inferred-types/dist/types/index";
-
-/**
- * **LiteralFn**`<TFn>`
- *
- * Receives any function `TFn` and makes sure that it is not using
- * generics to narrow the inputs coming into the function.
- *
- * **Related:** `IsLiteralFn`, `NarrowingFn`
- */
-export type LiteralFn<
-  TFn extends AnyFunction
-> =
-AsFnMeta<TFn>["hasProps"] extends true
-? AsFnMeta<TFn>["hasArgs"] extends true
-  ? ((...args: AsFnMeta<TFn>["args"]) => AsFnMeta<TFn>["returns"]) & AsFnMeta<TFn>["props"]
-  : (() => AsFnMeta<TFn>["returns"]) & AsFnMeta<TFn>["props"]
-: AsFnMeta<TFn>["hasArgs"] extends true
-  ? (...args: AsFnMeta<TFn>["args"]) => AsFnMeta<TFn>["returns"]
-  : () => AsFnMeta<TFn>["returns"] ;
-
-
-/**
- * **AsLiteralFn**`<TParams,TReturns,TProps>`
- *
- * Constructs a `LiteralFn` from component aspects of
- * a function.
- *
- * **Related:** `LiteralFn`, `NarrowingFn`, `AsNarrowingFn`
- */
-export type AsLiteralFn<
-  TParams extends Tuple | AnyFunction,
-  TReturn = unknown,
-  TProps extends Dictionary = EmptyObject
-> = TParams extends AnyFunction
-? LiteralFn<TParams>
-: TParams extends Tuple
-  ? IsNonEmptyObject<TProps> extends true
-    ? IsEqual<TParams, []> extends true
-      ? (() => TReturn) & TProps
-      : ((...args: TParams) => TReturn) & TProps
-  : IsEqual<TParams, []> extends true
-    ? () => TReturn
-    : (...args: TParams) => TReturn
-: never;

package/src/types/functions/LogicFunction.ts

@@ -1,11 +0,0 @@
- 
-/**
- * **LogicFunction**
- * 
- * A function -- with _optional_ parameters -- which returns a boolean value.
- */
-export type LogicFunction<
-  TReturns extends boolean = boolean
-> = (...args: any[]) => TReturns;
-
-

package/src/types/functions/NarrowingFn.ts

@@ -1,73 +0,0 @@
-import {
-  AnyFunction,
-  Dictionary,
-  EmptyObject,
-  IsEqual,
-  IsNarrowingFn,
-  IsNonEmptyObject,
-  Throw,
-  Tuple,
-  TypedFunction
-} from "inferred-types/dist/types/index";
-
-
-
-/**
- * **NarrowingFn**`<N>`
- *
- * Produces a function which helps to narrow down to the type passed in
- * by assigning generics to all input parameters.
- *
- * ```ts
- * // <T extends string>(name: string) => string
- * type Fn1 = NarrowingFn<(name: string) => string>;
- * // <T extends number>(v: T) => T
- * type Fn2 = NarrowingFn<number>;
- * // <T extends number>(v: T) => T
- * type Fn2 = NarrowingFn<42>;
- * ```
- *
- * **Related:** `LiteralFn`, `IsNarrowingFn`
- */
-export type NarrowingFn<
-  TFn extends AnyFunction
-> = TFn extends TypedFunction
-  ? IsEqual<Parameters<TFn>, []> extends true
-    ? Throw<
-        "no-parameters",
-        `To make a function a NarrowingFn it must have at least one parameter!`,
-        "NarrowingFn",
-        { library: "inferred-types"; params: TFn }
-      >
-    : IsNarrowingFn<TFn> extends true
-      ? TFn
-      : (<T extends Parameters<TFn>>(...args: T) => ReturnType<TFn>)
-  : NarrowingFn<TypedFunction>;
-
-
-/**
- * **AsNarrowingFn**`<TParams,TReturns,TProps>`
- *
- * Constructs a `NarrowingFn` from component aspects of
- * a function.
- *
- * **Related:** `LiteralFn`, `NarrowingFn`, `AsLiteralFn`
- */
-export type AsNarrowingFn<
-    TParams extends Tuple | TypedFunction,
-    TReturn = unknown,
-    TProps extends Dictionary = EmptyObject
-  > =
-TParams extends TypedFunction
-      ? NarrowingFn<TParams>
-  : TParams extends Tuple // this is the normal call structure
-      ? [IsNonEmptyObject<TProps>] extends [true]
-        ? [IsEqual<TParams, []>] extends [true]
-          ? (() => TReturn) & TProps
-          : (<T extends TParams>(...args: T) => TReturn) & TProps
-      : [IsEqual<TParams, []>] extends [true]
-        ? () => TReturn
-        : <T extends TParams>(...args: T) => TReturn
-    : never
-
-

package/src/types/functions/OnlyFnProps.ts

@@ -1,11 +0,0 @@
-import { AnyFunction, AsFnMeta } from "inferred-types/dist/types/index";
-
-/**
- * **OnlyFnProps**`<T>`
- *
- * Takes a function `T` and strips the function away leaving only
- * any key/values that were stored alongside it.
- */
-export type OnlyFnProps<
-  T extends AnyFunction
-> = AsFnMeta<T>["props"];

package/src/types/functions/PromiseAll.ts

@@ -1,13 +0,0 @@
-import { Tuple } from "inferred-types/dist/types/index";
-
-
-/**
- * **PromiseAll**
- *
- *
- */
-export interface PromiseAll<TKind = unknown> {
-  <T extends Tuple<PromiseLike<TKind>>>(...promises: T): {
-    [K in keyof T]: Awaited<T[K]>
-  };
-}