inferred-types 0.51.1 → 0.51.2

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

@@ -1,47 +0,0 @@
-import {
-  Scalar,
-  IsFalsy,
-  IsLength,
-  IsTruthy,
-  Keys,
-  AnyObject,
-  IsNever,
-  If,
-  Extends,
-  AsRecord
-} from "inferred-types/dist/types/index";
-
-
-/**
- * **ToBoolean**`<T>`
- *
- * Type utility which converts `T` into a boolean type regardless of
- * `T`'s underlying type.
- *
- * - _boolean_ values are proxied through
- * - _scalar_ values are tested with the JS Truthy test to return a true/false value
- * - _containers_ with no keys evaluate to false, with keys to true
- * - _never_, _null_, and _undefined_ map to false
- * - all other values return the wide "boolean" type
- */
-export type ToBoolean<T> = If<
-IsNever<T>,
-false,
-T extends boolean
-? T
-: T extends Scalar
-  ? If<
-      IsTruthy<T>,
-      true,
-      If<IsFalsy<T>, false, boolean>
-    >
-  : T extends readonly unknown[]
-    ? If<
-        IsLength<Keys<T>["length"], 0>,
-        false,
-        true
-      >
-    : T extends AnyObject
-      ? If<IsLength<Keys<AsRecord<T>>["length"], 0>, false, true>
-      : If<Extends<T, undefined>, false, boolean>
->;

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

@@ -1,41 +0,0 @@
-
-import {
-  AnyArray,
-  AnyFunction,
-  AnyObject,
-  Scalar,
-  IfEqual,
-  IfNever
-} from "inferred-types/dist/types/index";
-
-/**
- * **ToContainer**`<T>`
- *
- * Provides a narrowing feature for union types which _include_ the
- * option to be a `Container` but might also be a Scalar value or
- * a function.
- *
- * However, unlike a simple intersection with `readonly any[] | AnyObject`,
- * this type will detect where there is no overlap and instead of returning
- * a `never` value it will just convert to `AnyObject | AnyArray`:
- *
- * If the union of `T` with `Exclude<T, Scalar| undefined | AnyFunction>`
- * - is a _container_ than we're done we simply apply the Exclude and return the type
- * - is a **Scalar** value or _undefined_ we just convert to the generic `AnyObject | AnyArray`
- * - if we resolve to `unknown` or `any` then all we can logically do is wrap it into a readonly array (e.g. `[unknown]` or `[any]` respectively).
- */
-export type ToContainer<T> = IfNever<
-  Exclude<T, Scalar | undefined | AnyFunction>,
-  AnyObject | AnyArray,
-  // all non-never values
-  IfEqual<
-    Exclude<T, Scalar | undefined | AnyFunction>, any,
-    [any],
-    IfEqual<
-    Exclude<T, Scalar | undefined | AnyFunction>, unknown,
-    [unknown],
-    Exclude<T, Scalar | undefined | AnyFunction>
-    >
-  >
-
->;

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

@@ -1,76 +0,0 @@
-
-import {
-  As,
-  Join,
-  Tuple
- } from "inferred-types/dist/types/index";
-
-
-type AsJsonArray<T extends Tuple> = Join<
-  [
-    "[ ",
-    ...T,
-    " ]"
-  ]
->;
-
-// type ToJsonScalar<T> = T extends string
-// ? `"${T}"`
-// : T extends number
-// ? `${T}`
-// : T extends boolean
-// ? `${T}`
-// : T extends undefined
-// ? "undefined"
-// : T extends null
-// ? "null"
-// : never;
-
-// type KeyAndValue<
-//   TKey,
-//   TValue
-// > = [
-//   ", ",
-//   ToJsonScalar<TKey>,
-//   ": ",
-//   ToJsonScalar<TValue>,
-// ];
-
-// type Joined<
-//   TContent extends readonly string[]
-// > = Join<TContent>;
-
-// type JsonKeyValues<
-//   TObj extends Dictionary,
-//   TKeys extends readonly (ObjectKey & keyof TObj)[],
-//   TResult extends string = ""
-// > = [] extends TKeys
-// ? TResult
-// : JsonKeyValues<
-//     TObj,
-//     AfterFirst<TKeys>,
-//     Joined<[
-//       TResult, ...KeyAndValue<First<TKeys>, TObj[First<TKeys>]>
-//     ]>
-//   >;
-
-// type ToJsonObj<T extends Dictionary> = JsonKeyValues<T, Keys<T>>;
-
-
-export type ToJsonValue<T> = T extends string
-? `"${T}"`
-: T extends number
-? `${T}`
-: T extends boolean
-? `${T}`
-: T extends undefined
-? "undefined"
-: T extends null
-? "null"
-: T extends Tuple
-? AsJsonArray<
-    As<{[K in keyof T]: ToJsonValue<T[K]>}, Tuple>
-  >
-: never;
-
-

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

@@ -1,54 +0,0 @@
-import {
-  If,
-  ToNumericArray,
-  IsTrue,
-  IsFalse,
-  IsEqual,
-  IsArray,
-  IsTuple,
-  Throw,
-  Or
-} from "inferred-types/dist/types/index";
-
-
-/**
- * **ToNumber**`<T>`
- *
- * - Converts `T` into a numeric type:
- *    - if `T` is a Scalar/Object it's converted to a number where possible
- *    - if `T` is an array then each element will be converted to a number where possible
- *    - any non-numeric content which can not be converted to a number will be convert to `never`
- *    - a number or a numeric array will be proxied through "as is"
- */
-export type ToNumber<TValue> =  IsTuple<TValue> extends true
-
-  ? TValue extends readonly unknown[]
-    ? ToNumericArray<TValue> extends readonly (number | never)[]
-      ? ToNumericArray<TValue>
-      : Throw<
-          "can-not-convert",
-          `Attempt to convert a tuple into a numeric tuple failed!`,
-          "ToNumber",
-          { library: "inferred-types"; value: TValue }
-        >
-    : never
-  : TValue extends number
-    ? TValue
-    : TValue extends `${infer Num extends number}`
-      ? Num
-      : If<
-          Or<[ IsTrue<TValue>, IsEqual<TValue, "true"> ]>,
-          1,
-          If<
-            Or<[ IsFalse<TValue>, IsEqual<TValue, "false"> ]>,
-            0,
-            If<
-              IsArray<TValue>,
-              readonly (number | never)[],
-              never
-            >
-          >
-        >
-
-
-

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

@@ -1,43 +0,0 @@
-
-import {
-  AnyFunction,
-  AnyObject,
-  IsVueRef,
-  IsUndefined,
-  Narrowable,
-  Concat,
-  If,
-  IsNumericLiteral,
-  IsBooleanLiteral
-} from "inferred-types/dist/types/index";
-
-/**
- * **ToString**
- *
- * Converts _any_ type into a string representation.
- * This utility works as advertised but is in early stages
- * so expect it to be refined over time.
- *
- * **Related:** `AsString`
- */
-export type ToString<T> = T extends string
-  ? T
-  : T extends number ? If<IsNumericLiteral<T>, `${T}`, `${number}`>
-  : T extends boolean ? If<IsBooleanLiteral<T>, `${T}` , `${boolean}`>
-  : T extends null ? "null"
-  : IsUndefined<T> extends true ? "undefined"
-  : T extends AnyObject ? If<
-      IsVueRef<T>,
-      T,
-      Concat<["Ref<", T extends { value: Narrowable } ? ToString<T["value"]> : "", ">"]>,
-      T extends { name: string} ? `Object(${T["name"]})` : "Object"
-    >
-  : T extends symbol ? "symbol"
-  : T extends string[] ? "string[]"
-  : T extends number[] ? "number[]"
-  : T extends boolean[] ? "boolean[]"
-  : T extends AnyFunction[] ? "Function[]"
-  : T extends AnyObject[] ? "Object[]"
-  : T extends unknown[] ? "unknown[]"
-  : T extends any[] ? "any[]"
-  : "unknown";

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

@@ -1,15 +0,0 @@
-import {  AsString,  Tuple } from "inferred-types/dist/types/index";
-
-/**
- * **ToStringArray**`<T>`
- *
- * Receives a tuple of values and converts each item
- * into a _string_ value using the `ToString<T>` utility.
- */
-export type ToStringArray<T extends Tuple> = {
-  [K in keyof T]: AsString<T[K]>
-} extends readonly string[]
-? {
-  [K in keyof T]: AsString<T[K]>
-}
-: never;

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

@@ -1,11 +0,0 @@
- 
-
-/**
- * **ToUnion**`<T>`
- * 
- * Converts `T` -- which must be an array of something -- to 
- * a Union type.
- * 
- * **Related:** `TupleToUnion`
- */
-export type ToUnion<T extends any[]> = T[number];

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

@@ -1,28 +0,0 @@
-import { Whitespace } from "inferred-types/dist/types/index";
-
-type Process<
-S extends string
-> = string extends S
-? string
-: S extends `${Whitespace}${infer Right}`
-? Process<Right>
-: S extends `${infer Left}${Whitespace}`
-? Process<Left>
-: S;
-
-
-/**
- * Trims off blank spaces, `\n` and `\t` characters from both sides of a _string literal_.
- * ```ts
- * // "foobar"
- * type T = Trim<"\n\t  foobar ">;
- * // string
- * type T = Trim<string>;
- * ```
- */
-export type Trim<
-  S extends string
-> = Process<S> extends string
-? Process<S>
-: never;
-

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

@@ -1,14 +0,0 @@
-import { Whitespace } from "inferred-types/dist/types/index";
-
-/**
- * Trims off whitespace on left of string
- * ```ts
- * // "foobar "
- * type T = TrimLeft<"\n\t  foobar ">;
- * // string
- * type T = TrimLeft<string>;
- * ```
- */
-export type TrimLeft<S extends string> = string extends S ? string :
-  S extends `${Whitespace}${infer Right}` ?
-  TrimLeft<Right> : S;

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

@@ -1,14 +0,0 @@
-import { Whitespace } from "inferred-types/dist/types/index";
-
-/**
- * Trims off whitespace on left of string
- * ```ts
- * // "\n foobar"
- * type T = TrimRight<"\n foobar \t">;
- * // string
- * type T = TrimRight<string>;
- * ```
- */
-export type TrimRight<S extends string> = string extends S ? string :
-  S extends `${infer Right}${Whitespace}` ?
-  TrimRight<Right> : S;

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

@@ -1,19 +0,0 @@
-import { Keys } from "inferred-types/dist/types/index";
-
-/**
- * Converts a Tuple type into a _union_ of the tuple elements
- *
- * ```ts
- * const arr = [1, 3, 5] as const;
- * // 1 | 3 | 5
- * type U = TupleToUnion<typeof arr>;
- * ```
- *
- * **Note:** an empty array will be converted to a `string` type.
- */
-export type TupleToUnion<T> = T extends readonly unknown[]
-  ? Keys<T>["length"] extends 0
-    ? never
-    : T[number]
-  : never;
-

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

@@ -1,29 +0,0 @@
-import { ElementOf } from "../lists/ElementOf";
-
-// Existing utility: UnionToTuple (unchanged)
-type UnionToIntersection<U> = (
-  U extends unknown ? (arg: U) => 0 : never
-) extends (arg: infer I) => 0 ? I : never;
-
-type LastInUnion<U> = UnionToIntersection<
-  U extends unknown ? (x: U) => 0 : never
-> extends (x: infer L) => 0 ? L : never;
-
-type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never]
-  ? []
-  : [...UnionToTuple<Exclude<U, Last>>, Last];
-
-
-
-/**
- * **UnionArrayToTuple**`<T>`
- *
- * If you have a type which is an _array_ of a Union type but you want to
- * represent this as a Tuple, this utility  will make this conversion for you.
- *
- * **Related:** `UnionToTuple`
- */
-export type UnionArrayToTuple<T> = T extends any[]
-? UnionToTuple<ElementOf<T>>
-: never;
-

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

@@ -1,116 +0,0 @@
-import { UnionToTuple, TupleToUnion, Filter, IsUnion, Tuple, CamelCase, PascalCase, KebabCase, SnakeCase } from "inferred-types/dist/types/index";
-
-
-type Reduce<
-    T extends Tuple,
-    E
-> = TupleToUnion<
-    Filter<{
-        [K in keyof T]: T[K] extends E
-            ? never
-            : T[K]
-    }, never>
->;
-
-type Isolate<
-    T extends Tuple,
-    E
-> = TupleToUnion<
-    Filter<{
-        [K in keyof T]: T[K] extends E
-            ? T[K]
-            : never
-    }, never>
->;
-
-/**
- * **UnionFilter**`<U, E>`
- *
- * A type utility which receives a union type `U` and then eliminates
- * all elements of the union which _extend_ `E`.
- *
- * **Related:** `UnionRetain`
- */
-export type UnionFilter<U, E> = [U] extends [never]
-? never
-: [IsUnion<U>] extends [true]
-    ? Reduce<UnionToTuple<U>,E>
-    : [U] extends [E]
-        ? never
-        : U;
-
-/**
- * **UnionRetain**`<U, E>`
- *
- * A type utility which receives a union type `U` and then eliminates
- * all elements of the union which _do not extend_ `E`.
- *
- * **Related:** `UnionFilter`
- */
-export type UnionRetain<U, E> = [U] extends [never]
-? never
-: IsUnion<U> extends true
-    ? Isolate<UnionToTuple<U>,E>
-    : U extends E
-        ? U
-        : never;
-
-
-export type UnionMutationOp =
-| "Capitalize"
-| "Lowercase"
-| "CamelCase"
-| "PascalCase"
-| "SnakeCase"
-| "KebabCase";
-
-type Mutate<
-  TElements extends readonly unknown[],
-  TOp extends UnionMutationOp
-> = TOp extends "Capitalize"
-? {
-  [K in keyof TElements]: TElements[K] extends string
-    ? Capitalize<TElements[K]>
-    : TElements[K]
-  }
-: TOp extends "Lowercase"
-? {
-  [K in keyof TElements]: TElements[K] extends string
-    ? Lowercase<TElements[K]>
-    : TElements[K]
-  }
-: TOp extends "CamelCase"
-? {
-  [K in keyof TElements]: TElements[K] extends string
-    ? CamelCase<TElements[K]>
-    : TElements[K]
-  }
-: TOp extends "PascalCase"
-? {
-  [K in keyof TElements]: TElements[K] extends string
-    ? PascalCase<TElements[K]>
-    : TElements[K]
-  }
-: TOp extends "KebabCase"
-? {
-  [K in keyof TElements]: TElements[K] extends string
-    ? KebabCase<TElements[K]>
-    : TElements[K]
-  }
-: TOp extends "SnakeCase"
-? {
-  [K in keyof TElements]: TElements[K] extends string
-    ? SnakeCase<TElements[K]>
-    : TElements[K]
-  }
-: never;
-
-
-export type UnionMutate<
-  U,
-  Op extends UnionMutationOp
-> = [U] extends [never]
-? never
-: IsUnion<U> extends true
-    ? Mutate<UnionToTuple<U>,Op>[number]
-    : U;

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

@@ -1,30 +0,0 @@
-import {  IsUnion, LastInUnion } from "inferred-types/dist/types/index";
-
-
-type Process<U, Last = LastInUnion<U>> = [U] extends [never]
-? []
-: [IsUnion<U>] extends [true]
-    ? [Last, Exclude<U,Last>]
-    : U;
-
-  /**
-   * **ShiftUnion**`<U>`
-   *
-   * Takes a type `U` and returns a tuple of the form:
-   * ```ts
-   * [shifted, remaining]
-   * ```
-   *
-   * Where `shifted` is the union segment which has been _removed_
-   * and the `remaining` value is the value with that segment removed.
-   *
-   * **Note:**
-   * - you should not presume any explicit _ordering_ for removing elements
-   * from the union
-   * - when calling `ShiftUnion`<U>` where `U` is _not_ a union you will
-   * get the tuple `[never, U]`
-   */
-  export type UnionShift<U, Last = LastInUnion<U>> =
-  Process<U,Last> extends readonly unknown[]
-    ? IsUnion<U> extends true ? [Last, Exclude<U,Last>] : U
-    : [never, IsUnion<U> extends true ? [Last, Exclude<U,Last>] : U];

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

@@ -1,10 +0,0 @@
-/**
- * **UnionToIntersection**`<U>`
- * 
- * Type utility which converts a union type to an intersection
- */
-export type UnionToIntersection<U> = (
-  U extends U ? (x: U) => unknown : never
-) extends (x: infer R) => unknown
-  ? R
-  : never;

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

@@ -1,31 +0,0 @@
-
-/**
- * UnionToIntersection<{ foo: string } | { bar: string }> =
- *  { foo: string } & { bar: string }.
- */
-type UnionToIntersection<U> = (
-  U extends unknown ? (arg: U) => 0 : never
-) extends (arg: infer I) => 0
-  ? I
-  : never;
-
-/**
- * LastInUnion<1 | 2> = 2.
- */
-export type LastInUnion<U> = UnionToIntersection<
-  U extends unknown ? (x: U) => 0 : never
-> extends (x: infer L) => 0
-  ? L
-  : never;
-
-
-/**
- * **UnionToTuple**`<1 | 2>` => [1, 2]
- *
- * Converts union members into a tuple.
- *
- * **Related**: `UnionArrayToTuple`
- */
-export type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never]
-? []
-: [...UnionToTuple<Exclude<U, Last>>, Last];

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

@@ -1,18 +0,0 @@
-
-/**
- * **UnionWithAll**`<TList,TUnion>`
- * 
- * Type utility which iterates through each element of `TList` and creates a 
- * a union between the current value and `TUnion`.
- * ```ts
- * type Arr = [1,2,"foo"];
- * // [1,2, "foo" | number]
- * type Num = UnionWithAll<Arr, number>;
- * ```
- */
-export type UnionWithAll<
-  TList extends readonly unknown[],
-  TUnion
-> = {
-  [K in keyof TList]: TList[K] | TUnion
-};

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

@@ -1,28 +0,0 @@
-import { TypedFunction } from "inferred-types/dist/types/index";
-
-
-type Process<
-  T extends readonly unknown[]
-> = {
-  [K in keyof T]: T[K] extends TypedFunction
-  ? ReturnType<T[K]>
-  : T[K];
-};
-
-/**
- * **ValueOrReturnValue**`<TEval>`
- *
- * Takes a value or a tuple of values in `TEval` and evaluates what
- * the item's _return type_ is when an element is a function; otherwise it just proxies
- * the element's type forward.
- *
- * ### Example
- * ```ts
- * // [true, "foo", "bar"]
- * type T = ValueOrReturns<[true, "foo", () => "bar"]>;
- * ```
- */
-export type ValueOrReturnValue<TEval> = TEval extends readonly unknown[]
-? Process<TEval>
-: Process<[TEval]>[0];
-