inferred-types 0.37.0 → 0.37.1

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

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

@@ -1,20 +0,0 @@
-import { Narrowable } from "../Narrowable";
-
-/**
- * **IsUndefined**
- *
- * Boolean type utility returns `true` if `T` is undefined; `false` otherwise
- */
-export type IsUndefined<T extends Narrowable> = T extends undefined ? true : false;
-
-/**
- * **IfUndefined**`<T, IF, ELSE>`
- *
- * Type utility which returns `IF` type when `T` is an _undefined_
- * otherwise returns `ELSE` type.
- */
-export type IfUndefined<
-  T,
-  IF extends Narrowable,
-  ELSE extends Narrowable
-> = IsUndefined<T> extends true ? IF : ELSE;

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

@@ -1,12 +0,0 @@
-import { NarrowlyContains } from "./array";
-
-/**
- * **Or**`<T>`
- *
- * Takes an array of boolean values and produces a boolean OR across these values
- */
-export type Or<T extends readonly boolean[]> = NarrowlyContains<true, T> extends true
-  ? true
-  : NarrowlyContains<boolean, T> extends true
-  ? boolean
-  : false;

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

@@ -1,42 +0,0 @@
-import { IsStringLiteral } from "src/types/boolean-logic";
-import { Narrowable } from "../Narrowable";
-/**
- * **StartsWith**<TValue, TStartsWith>
- *
- * A type utility which checks whether `T` _starts with_ the string literal `U`.
- *
- * If both `T` and `U` are string literals then the type system will resolve
- * 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 string,
-  TStartsWith extends string
-> = IsStringLiteral<TStartsWith> extends true
-  ? IsStringLiteral<TValue> extends true // both literals
-    ? TValue extends `${TStartsWith}${string}`
-      ? true
-      : false
-    : boolean
-  : boolean;
-
-/**
- * **IfStartsWith**<TValue, TStartsWith, IF, ELSE, MAYBE>
- *
- * Type utility which converts type to `IF` type _if_ TValue _starts with_ `TStartsWith` but
- * otherwise converts type to `ELSE`.
- *
- * Note, that there is also an optional `MAYBE` type
- * 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.
- */
-export 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;

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

@@ -1,58 +0,0 @@
-import { IsObject } from "src/types/boolean-logic";
-import { SimplifyObject } from "../SimplifyObject";
-import { IfExtends } from "./Extends";
-import { IfOptionalLiteral } from "./IsLiteral";
-import { IfUndefined } from "./IsUndefined";
-
-/**
- * **TypeDefault**
- *
- * A type utility designed to help maintain strong and narrow types where
- * you have a value `T` which _might_ be **undefined** and a type `D` which
- * defines all the _default_ type for `T`.
- *
- * - In all cases we compare first whether `T` is undefined and replace it's
- * type with `D` 1-for-1 if it is
- * - To address a larger set of use cases, when `D` _extends_ an object we will
- * compare each property of `D` against `T`
- * ```ts
- * type I = { foo?: "foo" |  undefined; bar?: 42 | 53 | undefined };
- * type D = { foo: "foo"; bar: 53 };
- * type DF = TypeDefault<I,D>; // `D`
- * const i = { foo: undefined, bar: 99 } as const;
- * type DF2 = TypeDefault<typeof i, D>; // `{ foo: "foo"; bar: 99 }`
- * ```
- */
-export type TypeDefault<T, D> = //
-  IsObject<D> extends true //
-    ? IsObject<T> extends true
-      ? // both T and D are objects; start by iterating over D
-        SimplifyObject<{
-          [K in keyof D]: K extends keyof T
-            ? // both D[T] and K[T] are present
-              TypeDefault<T[K], D[K]>
-            : // only D[K] present
-              D[K];
-        }>
-      : // T is not an object, but D is
-        IfUndefined<
-          T, // check if T is undefined
-          D, // use D as the type
-          Exclude<T, undefined> // use T as the type but remove "undefined"
-        >
-    : // neither D or T is an object
-      IfUndefined<
-        T, // check whether is T is undefined
-        D, // assign to D if it is
-        IfOptionalLiteral<
-          T, // if T is a literal
-          IfExtends<
-            D,
-            T,
-            D, // use D since it extends the value of T
-            Exclude<T, undefined> // use T's literal value minus "undefined"
-          >,
-          // T is a wide type
-          Exclude<T, undefined>
-        >
-      >;

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

@@ -1,57 +0,0 @@
-import { IsEqual } from "./equivalency";
-import { AfterFirst, First } from "../lists";
-import { Narrowable } from "../Narrowable";
-
-export type IsArray<T> = [T] extends [any[]] ? true : [T] extends [readonly any[]] ? true : false;
-export type IsReadonlyArray<T> = T extends readonly any[] ? true : false;
-
-/**
- * **IfArray**`<T, IF, ELSE>`
- *
- * Type utility which convert to type `IF` or `ELSE` based on whether `T` is an array
- */
-export type IfArray<
-  T extends Narrowable,
-  IF extends Narrowable,
-  ELSE extends Narrowable
-> = IsArray<T> extends true ? IF : ELSE;
-
-/**
- * **IfArray**`<T, IF, ELSE>`
- *
- * Type utility which convert to type `IF` or `ELSE` based on whether `T` is a readonly array
- */
-export type IfReadonlyArray<
-  T extends Narrowable,
-  IF extends Narrowable,
-  ELSE extends Narrowable
-> = IsReadonlyArray<T> extends true ? IF : ELSE;
-
-/**
- * **Contains**`<T, A>`
- *
- * Type utility which checks whether a type `T` exists within an array `A`. Result is
- * `true` if `T` _extends_ any element in `A` making it match widely against `A`. If you
- * prefer a narrower match you can use `NarrowlyContains<T,A>` instead.
- */
-export type Contains<T extends Narrowable, A extends readonly any[]> = First<A> extends T
-  ? true
-  : [] extends AfterFirst<A>
-  ? false
-  : Contains<T, AfterFirst<A>>;
-
-/**
- * **NarrowlyContains**`<T, A>`
- *
- * Type utility which checks whether a type `T` exists within an array `A`. Result is
- * `true` if `T` _extends_ any element in `A` making it match widely against `A`. If you
- * prefer a wider match you can use `Contains<T,A>` instead.
- */
-export type NarrowlyContains<T extends Narrowable, A extends readonly any[]> = IsEqual<
-  First<A>,
-  T
-> extends true
-  ? true
-  : [] extends AfterFirst<A>
-  ? false
-  : NarrowlyContains<T, AfterFirst<A>>;

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

@@ -1,84 +0,0 @@
-import { Narrowable } from "../Narrowable";
-
-export type IsBoolean<T> = [T] extends [boolean] ? true : false;
-
-/**
- * Type utility which returns `true` or `false` based on
- * whether the type holds the narrow "true" type.
- * ```ts
- * // true
- * type T = IsTrue<true>;
- * // boolean
- * type U = IsTrue<boolean>;
- * // false
- * type F = IsTrue<false>;
- * type F2 = IsTrue<"false">;
- * ```
- */
-export type IsTrue<T extends Narrowable> = IsBoolean<T> extends true
-  ? // is a boolean
-    T extends true
-    ? true
-    : T extends false
-    ? false
-    : unknown
-  : // not a boolean
-    false;
-
-export type IsFalse<T extends Narrowable> = IsBoolean<T> extends true
-  ? // is a boolean
-    T extends false
-    ? true
-    : true extends T
-    ? false
-    : // is of boolean type; therefore narrow type is unknown
-      unknown
-  : // not a boolean
-    false;
-
-/**
- * Type utility which checks for literal `true` value and then switches type
- * to the IF, ELSE, or MAYBE generic types passed in where _maybe_ is when T
- * is the wide type of `boolean`
- */
-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 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.
- */
-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 extends Narrowable,
-  ELSE extends Narrowable
-> = IsBooleanLiteral<T> extends true ? IF : ELSE;

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

@@ -1,15 +0,0 @@
-/**
- * **Equal**`<X,Y>`
- *
- * Type utility which tests whether two types -- `X` and `Y` -- are exactly the same type
- */
-export type IsEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
-  ? true
-  : false;
-
-/**
- * **NotEqual**`<X,Y>`
- *
- * Type utility which tests whether two types -- `X` and `Y` -- are _not_ exactly the same type
- */
-export type NotEqual<X, Y> = true extends IsEqual<X, Y> ? false : true;

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

@@ -1,14 +0,0 @@
-export * from "./array";
-export * from "./Includes";
-export * from "./boolean";
-export * from "./IsScalar";
-export * from "./IsLiteral";
-export * from "./IsUndefined";
-export * from "./Extends";
-export * from "./HasParameters";
-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,30 +0,0 @@
-import { FunctionType } from "../FunctionType";
-import { Mutable } from "../Mutable";
-import { Narrowable } from "../Narrowable";
-
-/**
- * **IsObject**
- *
- * Boolean type utility used to check whether a type `T` is an object
- */
-export type IsObject<T> = Mutable<T> extends Record<string, any>
-  ? // an object of some type
-    T extends FunctionType
-    ? // when a function with props is found, categorize as a function not object
-      false
-    : Mutable<T> extends any[]
-    ? // Array's are objects too but in our narrower definition we're looking only
-      // dictionary based arrays.
-      false
-    : true
-  : false;
-
-/**
- * **IfObject**
- *
- * Branch type utility with return `IF` when `T` extends an object type
- * and `ELSE` otherwise
- */
-export type IfObject<T, IF extends Narrowable, ELSE extends Narrowable> = IsObject<T> extends true
-  ? IF
-  : ELSE;

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

@@ -1,21 +0,0 @@
-import { Narrowable } from "src/types";
-
-/**
- * **IsString**
- *
- * Type utility which returns true/false based on whether `T` is a
- * string (wide or narrow).
- */
-export type IsString<T> = T extends string ? true : false;
-
-/**
- * **IfString**
- *
- * Type utility which determines if `T` is a _string_ (wide or narrow) and
- * returns `IF` type if it is, otherwise returns the type `ELSE`.
- */
-export type IfString<
-  T extends Narrowable, //
-  IF extends Narrowable,
-  ELSE extends Narrowable
-> = IsString<T> extends true ? IF : IsString<T> extends false ? ELSE : IF | ELSE;

package/src/types/dictionary/DictChangeValue.ts

@@ -1,34 +0,0 @@
-import { SimplifyObject } from "../SimplifyObject";
-
-/**
- * Allow a dictionary have it's value's type changed to `T` while maintaining the keys in
- * the original object `I` so long as the original value for the KV pair extends `V`.
- *
- * If `V` is not specified then it defaults to _any_ and therefore all KVs are preserved.
- *
- * ```ts
- * type Obj = { foo: "hello", bar: 42, baz: () => "world" };
- * // { foo: number, bar: number, baz: number };
- * type AllNumbers = DictChangeValue<Obj, number>;
- * // { foo: number }
- * type StringToBool = DictChangeValue<Obj, boolean, string>
- * ```
- */
-export type DictChangeValue<
-  /** the object who's value-type we're changing */
-  I extends Record<string, any>,
-  /** the return type that functions should be modified to have */
-  T extends any,
-  /**
-   *The type we expect in the value; if the value extends type `V` then the value will
-   * be converted to type `O`; if not then the KV pair will be discarded
-   */
-  V extends any = any
-> = SimplifyObject<
-  {
-    [K in keyof I]: I[K] extends V
-      ? // it's a function (or at least the scoped down type of function we're looking for)
-        Record<K, T>
-      : never;
-  }[keyof I]
->;

package/src/types/dictionary/DictPartialApplication.ts

@@ -1,30 +0,0 @@
-import { SimplifyObject } from "../SimplifyObject";
-
-/**
- * Given a dictionary of key/values, where the value is a function, this
- * type utility will maintain the keys but change the values to whatever
- * the `ReturnType` of the function was.
- * ```ts
- * const api = {
- *    val: 42,
- *    hi: (name: string) => `hi ${name}`,
- *    bye: (name: string) => `bye ${name}`
- * };
- * // { hi: string; bye: string }
- * type Test = UnwrapValue<typeof api>
- * // { val: number; foo: string; bar: string }
- * type Test2 = UnwrapValue<typeof api, false>
- * ```
- */
-export type DictPartialApplication<
-  T extends Record<string, any>,
-  I extends boolean = true
-> = SimplifyObject<
-  {
-    [K in keyof T]: T[K] extends (...args: any[]) => any
-      ? Record<K, ReturnType<T[K]>>
-      : true extends I
-      ? never
-      : Record<K, T[K]>;
-  }[keyof T]
->;

package/src/types/dictionary/DictPrependWithFn.ts

@@ -1,23 +0,0 @@
-import { SimplifyObject } from "../SimplifyObject";
-
-/**
- * **DictPrependWithFn**
- *
- * Given a strongly typed object `<T>`, this utility will inject a function call with
- * arguments `<A>` and then return what had subsequently been the value of the property.
- * 
- * Should you only want to apply this treatment to _some_ of the properties you can
- * pass in a value `<E>` which will ensure that only properties which _extend_ `E` will be
- * modified.
- */
-export type DictPrependWithFn<
-  T extends Record<string, any>,
-  A extends any[],
-  E extends any = any
-> = SimplifyObject<
-  {
-    [K in keyof T]: T[K] extends E 
-      ? Record<K, (...args: A) => T[K]>
-      : Record<K, T[K]>;
-  }[keyof T]
->;

package/src/types/dictionary/DictReturnValues.ts

@@ -1,27 +0,0 @@
-import { SimplifyObject } from "../SimplifyObject";
-
-/**
- * **DictReturnValues**
- *
- * A type utility which receives an object `<T>` and then modifies
- * the return type of any properties which are a function to have this
- * new **ReturnType** `<R>`. Optionally you can specify a particular return type which
- * you are targeting and then
- */
-export type DictReturnValues<
-  /** the object which we expect to have props with function values */
-  T extends Record<string, any>,
-  /** the return type that functions should be modified to have */
-  R extends any,
-  /** optionally this utility can target only functions with a certain existing return value */
-  O extends (...args: any[]) => any = (...args: any[]) => any
-> = SimplifyObject<
-  {
-    [K in keyof T]: T[K] extends O
-      ? // it's a function (or at least the scoped down type of function we're looking for)
-        T[K] extends (...args: infer A) => any
-        ? Record<K, (...args: A) => R>
-        : Record<K, T[K]>
-      : Record<K, T[K]>;
-  }[keyof T]
->;

package/src/types/dictionary/Get.ts

@@ -1,14 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/**
- * Get the type of a property of an object:
- * ```ts
- * const car = { make: "Chevy", model: "Malibu", }
- * ```
- */
-export type Get<T, K> = K extends `${infer FK}.${infer L}`
-  ? FK extends keyof T
-    ? Get<T[FK], L>
-    : never
-  : K extends keyof T
-  ? T[K]
-  : never;