inferred-types 0.51.1 → 0.51.2

package/src/types/lists/Length.ts

@@ -1,65 +0,0 @@
-import type {
-  Abs,
-  Container,
-  If,
-  IsEqual,
-  ObjectKey,
-  Or,
-  RemoveIndexKeys,
-  StrLen,
-  UnionToTuple
-} from "inferred-types/dist/types/index";
-
-type _Keys<
-T extends object
-> = UnionToTuple<keyof RemoveIndexKeys<T>>;
-
-type ProcessString<T extends string> = If<
-  IsEqual<T,string>,
-  number,
-  StrLen<T> extends number
-  ? StrLen<T>
-  : never
->
-
-
-
-/**
- * Utility type which returns the length of:
- *
- * - an _array_ (provides the number of elements)
- * - an _object_ (provides the number of keys)
- * - a _string_ (provides the number of chars)
- * - a _number_ (it will provide the number of digits, excluding `-` if present)
- *
- * ```ts
- * type Three = Length<[ "a", "b", "c" ]>;
- * ```
- */
-export type Length<
-  T extends Container | string | number
-  > = T extends readonly unknown[]
-? T["length"]
-: T extends number
-? number extends T
-  ? number
-  : ProcessString<`${Abs<T>}`>
-: T extends string
-  ? ProcessString<T>
-: T extends object
-    ? If<
-        Or<[
-          IsEqual<T, string[]>,
-          IsEqual<T, number[]>,
-          IsEqual<T, boolean[]>,
-          IsEqual<T, unknown[]>,
-          IsEqual<keyof T, string | symbol>,
-          IsEqual<keyof T, string>,
-        ]>,
-        number,
-        _Keys<T> extends readonly ObjectKey[]
-          ? _Keys<T>["length"]
-          : never
-      >
-    : never;
-

package/src/types/lists/LogicalReturns.ts

@@ -1,30 +0,0 @@
- 
-
-import { LogicFunction } from "../functions";
-
-type Process<
-TValues extends readonly (boolean | LogicFunction)[],
-_TParams extends readonly unknown[] = []
-> = {
-[K in keyof TValues]: TValues[K] extends ((...args: any[]) => boolean)
-  ? ReturnType<TValues[K]>
-  : TValues[K]
-}
-
-
-/**
- * **LogicalReturns**`<TValues, TParams>`
- * 
- * Given a known tuple of values, this utility will reduce it to
- * another tuple of items which are either a _boolean type_ or a function
- * with a boolean return. In the latter case the function's return value
- * will be represented in the Tuple.
- * 
- * **Related**: `ReturnTypes` and `TruthyReturns`
- */
-export type LogicalReturns<
-  TValues extends readonly (boolean | LogicFunction)[],
-  _TParams extends readonly unknown[] = []
-> = Process<TValues, _TParams> extends readonly boolean[]
-? Process<TValues, _TParams>
-: never;

package/src/types/lists/MaxLength.ts

@@ -1,44 +0,0 @@
-import { IsGreaterThan } from "../boolean-logic";
-import { If } from "../boolean-logic/branching/If";
-import { StrLen } from "../string-literals";
-import { AfterFirst } from "./AfterFirst";
-import { First } from "./First";
-
-type Reduce<
-T extends readonly ([string, number])[],
-TMax extends number = 0,
-TVal extends string = ""
-> = [] extends T
-? TVal
-: Reduce<
-    AfterFirst<T>,
-    First<T> extends [string, infer Len extends number]
-    ? If<
-        IsGreaterThan<Len, TMax>,
-        Len,
-        TMax
-      >
-    : TMax,
-    First<T> extends [infer Val extends string, infer Len extends number]
-    ? If<
-        IsGreaterThan<Len, TMax>,
-        Val,
-        TVal
-      >
-    : TVal
-  >
-
-/**
- * **MaxLength**`<T>`
- *
- * Utility which reduces a tuple of strings to only the
- * string which is longest.
- */
-export type MaxLength<T> =
-T extends readonly string[]
-? Reduce<{
-  [K in keyof T]: T[K] extends string
-    ? [T[K], StrLen<T[K]>]
-    : never
-  }>
-: never;

package/src/types/lists/NumericKeys.ts

@@ -1,55 +0,0 @@
-import { Tuple, Length, ToNumber, AfterFirst, First, IsReadonlyArray, If } from "inferred-types/dist/types/index";
-
-type Recurse<
-  TList extends Tuple,
-  TResults extends Tuple = []
-> = [] extends TList
-  ? [] extends TResults
-    ? number[]
-    : TResults
-  : Recurse<
-      AfterFirst<TList>,
-      [
-        ...TResults,
-        ToNumber<First<TList> >
-      ]
-    >;
-
-type Convert<
-  TList extends Tuple
-> = Length<TList> extends 0
-    ? number[]
-    : Recurse<{
-      [K in keyof TList]: K
-    }>;
-
-type Process<
-  TList extends Tuple
-> = If<
-  IsReadonlyArray<TList>,
-  TList["length"] extends 0
-    ? number[]
-    : Readonly<Convert<TList>>,
-  Convert<TList>
->;
-
-/**
- * **NumericKeys**<`TList`>
- *
- * Will provide a readonly tuple of numeric keys for
- * a given literal array and an empty array otherwise.
- *
- * ```ts
- * type Arr = ["foo", "bar", "baz"];
- * // readonly [0, 1, 2]
- * type T = NumericKeys<Arr>;
- * ```
- *
- * **Related:** `Keys`
- */
-export type NumericKeys <
-  TList extends Tuple
-> = Process<TList> extends readonly number[]
-  ? Process<TList>
-  : never;
-

package/src/types/lists/NumericSort.ts

@@ -1,183 +0,0 @@
-import { Container } from "../base-types"
-import {  As, IsStringLiteral } from "../boolean-logic"
-import { IsEqual } from "../boolean-logic/operators/IsEqual"
-import { Get } from "../dictionary/Get"
-import { AsNumericArray } from "./AsNumericArray"
-import { RetainByProp } from "./RetainByProp"
-import { Reverse } from "./Reverse"
-
-type Iterator<
-  N,
-  iterator extends number[] = []
-> = iterator['length'] extends N
-    ? iterator
-    : Iterator<N, [any, ...iterator]>
-
-type Drop1<xs extends any[]> =
-  xs extends [any, ...infer tail] ? tail : []
-
-type LessThanOrEqual<
-  a extends number[],
-  b extends number[]
-> =
-  [a, b] extends [[], [any, ...any]]
-    ? true
-    : [a, b] extends [[any,...any], []]
-    ? false
-    : [a, b] extends [[], []]
-    ? true
-    : LessThanOrEqual<Drop1<a>, Drop1<b>>
-
-type GreaterThan<
-  a extends number[],
-  b extends number[]
-> =
-  [a, b] extends [[], [any, ...any]]
-    ? false
-    : [a, b] extends [[any,...any], []]
-    ? true
-    : [a, b] extends [[], []]
-    ? false
-    : GreaterThan<Drop1<a>, Drop1<b>>
-
-
-type FilterLessThanOrEqual<
-  TVal,
-  TValues extends number[],
-  TOut extends number[] = []
-> =
-  TValues extends [infer head, ...infer tail extends number[]]
-    ? LessThanOrEqual<Iterator<TVal>, Iterator<head>> extends true
-      ? [...TOut, head, ...FilterLessThanOrEqual<TVal, tail, TOut>]
-      : [...TOut, ...FilterLessThanOrEqual<TVal, tail, TOut>]
-    : []
-
-type FilterGreaterThan<
-  TVal,
-  TValues extends number[],
-  TOut extends number[] = []
-> =
-  TValues extends [infer head, ...infer tail extends number[]]
-    ? GreaterThan<Iterator<TVal>, Iterator<head>> extends true
-      ? [...TOut, head, ...FilterGreaterThan<TVal, tail, TOut>]
-      : [...TOut, ...FilterGreaterThan<TVal, tail, TOut>]
-    : []
-
-
-/**
- * Local Sort for values at root (aka, not offset)
- */
-type _Sort<
-    TValues extends readonly number[],
-    TReverse extends boolean,
-  > = TValues extends [infer head, ...infer tail extends number[]]
-  ? TReverse extends true
-    ? [
-      ..._Sort<
-        FilterLessThanOrEqual<head, tail>,
-        TReverse
-      >, head,
-      ..._Sort<
-        FilterGreaterThan<
-          head,
-          tail
-        >,
-        TReverse
-      >]
-    : [
-        ..._Sort<
-          FilterGreaterThan<head, tail>,
-          TReverse
-        >,
-        head,
-        ..._Sort<
-          FilterLessThanOrEqual<head, tail>,
-          TReverse
-        >
-      ]
-  : [];
-
-
-type _SortOffset<
-  TContainers extends readonly Container[],
-  TOffset extends string
-> = TContainers extends [infer head extends Container, ...infer rest extends Container[]]
-  ? [
-      ..._SortOffset<
-        As<RetainByProp<
-          rest,
-          Get<head, TOffset>,
-          TOffset,
-          "lessThanOrEqual"
-        >, Container[]>,
-        TOffset
-      >,
-      head,
-      ..._SortOffset<
-        As<RetainByProp<
-          rest,
-          Get<head, TOffset>,
-          TOffset,
-          "greaterThan"
-        >, Container[]>,
-        TOffset
-      >
-    ]
-  : [];
-
-
-
-
-export type NumericSupportOptions<
-  TOrder extends "ASC" | "DESC" | undefined = "ASC" | "DESC"  | undefined,
-  TOffset extends string | undefined = string | undefined
-> = {
-  /**
-   * by default this is set to sort by _ascending_ order but this can be
-   * reversed by changing order to `DESC`.
-   */
-  order?: TOrder;
-
-  /**
-   * by default, the sorting will expect the numeric value to exist
-   * as the base type, however, if you are using some sort of "container"
-   * object you may prefer to _offset_
-   */
-  offset?: TOffset;
-}
-
-
-/**
- * **NumericSort**`<TValues, [TOpt]>`
- *
- * Sorts the values in a tuple numerically.
- *
- * - _values_ can be a `number` or `${number}`
- *
- * Options:
- * - `order`: defaults to `ASC` but can be set to `DESC`
- * - `offset`:  if you have _containers_ as values, you can specify an offset to use to look for the numeric value
- */
-export type NumericSort<
-  TValues extends any[],
-  TOpt extends NumericSupportOptions = NumericSupportOptions
-> = IsStringLiteral<TOpt["offset"]> extends true
-? [IsEqual<TOpt["order"], "ASC">] extends [true]
-  ? _SortOffset<
-      TValues,
-      As<TOpt["offset"], string>
-    >
-  : Reverse<
-      _SortOffset<
-        TValues,
-        As<TOpt["offset"], string>
-      >
-    >
-
-
-: _Sort<
-  AsNumericArray<TValues>,
-  [IsEqual<TOpt["order"], "DESC">] extends [true]
-    ? true
-    : false
-  >;

package/src/types/lists/Pop.ts

@@ -1,39 +0,0 @@
-import { Concat, Tuple, IsStringLiteral, Chars, IsWideType } from "inferred-types/dist/types/index";
-
-type _Pop<
-  TVal extends Tuple
-> = TVal extends [...(infer Rest), unknown]
-? Rest
-: never;
-
-/**
- * **Pop**`<TList>`
- *
- * Removes the last element of a list.
- * ```ts
- * // [1,2]
- * type T = Pop<[1,2,3]>;
- * ```
- *
- * - to provide additional utility, you can also pass
- * in a string literal and get back the literal with the last
- * character removed.
- */
-export type Pop<
-  TList extends Tuple | string
-> = TList extends string
-  ? IsWideType<TList> extends true
-    ? string
-    :IsStringLiteral<TList> extends true
-      ? TList extends string
-        ? TList extends ""
-          ? ""
-          : Chars<TList> extends readonly string[]
-            ? Concat<_Pop<Chars<TList>>>
-            : never
-        : never
-      : string
-    : _Pop<Exclude<TList, string>>;
-
-
-

package/src/types/lists/Push.ts

@@ -1,25 +0,0 @@
-import { As } from "../boolean-logic/narrowing/As";
-
-type Process<
-  TList extends readonly unknown[],
-  TValue,
-> = [
-  ...TList,
-  TValue
-];
-
-
-/**
- * **Push**`<TList,TVal,[TCondition]>`
- * 
- * Pushes a value `TVal` onto an existing list `TList`.
- * 
- * - If you want to make the push conditional you can add `TCondition`
- */
-export type Push<
-  TList extends readonly unknown[], 
-  TVal,
-  TCondition = true
-> = [TCondition] extends [true] 
-  ? As<Process<TList,TVal>, readonly unknown[]>
-  : TList

package/src/types/lists/ReplaceLast.ts

@@ -1,14 +0,0 @@
-
-import { Pop } from "inferred-types/dist/types/index";
-
-/**
- * **ReplaceLast**`<TList,TVal>`
- *
- * Replaces the _last_ element of `TList` with the value of `TVal`.
- */
-export type ReplaceLast<
-  TList extends readonly any[],
-  TVal
-> = Pop<TList> extends readonly unknown[]
-  ? [...Pop<TList>, TVal]
-  : never;

package/src/types/lists/Retain.ts

@@ -1,81 +0,0 @@
-import {
-  Compare,
-  ComparatorOperation,
-  TupleToUnion,
-  Or,
-  IsEqual,
-  RemoveNever,
-} from "inferred-types/dist/types/index";
-
-/**
- * Iterates over each element of the Tuple
- */
-type SingleFilter<
-  TList extends readonly unknown[],
-  TFilter,
-  TOp extends ComparatorOperation,
-  Result extends unknown[] = []
-> = TList extends [infer Head, ...infer Rest]
-  ? [Compare<Head,TOp, TFilter>] extends [true]
-    ? SingleFilter<Rest, TFilter, TOp, [...Result, Head]>
-    : SingleFilter<Rest, TFilter, TOp, Result> // filter out
-  : Result;
-
-
-type Process<
-  TList extends readonly unknown[],
-  TComparator,
-  TOp extends ComparatorOperation
-> = TList extends unknown[]
-? SingleFilter<TList, TComparator, TOp>
-: // readonly only tuples
-  TList extends readonly unknown[]
-    ? Readonly<
-        SingleFilter<[...TList], TComparator, TOp>
-      >
-    : never;
-
-type PrepList<
-  T extends readonly unknown[],
-  O extends ComparatorOperation
-> = Or<[
-    IsEqual<O, "contains">,
-    IsEqual<O, "startsWith">,
-    IsEqual<O, "endsWith">,
-  ]> extends true
-  ? RemoveNever<{
-    [K in keyof T]: T[K] extends string | number
-      ? T[K]
-      : never
-  }>
-  : T;
-
-/**
- * **Retain**`<TList, TFilter>`
- *
- * Allows a known tuple `TList` to be reduced to just those elements which
- * _extend_ type `TFilter`.
- *
- * - `TFilter` can be single value or a array of values
- * - when the filter is an array then they are combined in a logical OR operation
- *
- * **Related:** `Filter`
- */
-export type Retain<
-  TList extends readonly unknown[],
-  TComparator,
-  TOp extends ComparatorOperation = "extends"
-
-> = PrepList<TList, TOp> extends readonly unknown[]
-? [TComparator] extends [unknown[]]
-  ? Process<
-      PrepList<TList, TOp>,
-      TupleToUnion<TComparator>,
-      TOp
-    >
-  : Process<
-      PrepList<TList, TOp>,
-      TComparator,
-      TOp
-    >
-: never;

package/src/types/lists/RetainByProp.ts

@@ -1,105 +0,0 @@
-import {
-  ComparatorOperation,
-  Compare,
-  IsArray,
-  IfNever,
-  If,
-  TupleToUnion,
-  RemoveNever,
-  IsDotPath,
-  Throw,
-  Get
-} from "inferred-types/dist/types/index";
-
-
-/**
- * Iterates over each element of the Tuple
- */
-type SingleFilter<
-  TList extends readonly unknown[],
-  TComparator,
-  TProp extends string,
-  TOp extends ComparatorOperation,
-  Result extends unknown[] = []
-> = TList extends [infer Head, ...infer Rest]
-  ? [Compare<
-      Get<Head, TProp>,
-      TOp,
-      TComparator
-    >] extends [true]
-    ? SingleFilter<Rest, TComparator, TProp, TOp, [...Result, Head]>
-    : SingleFilter<Rest, TComparator, TProp, TOp, Result> // filter out
-  : Result;
-
-
-type Process<
-  TList extends unknown[] | readonly unknown[],
-  TComparator,
-  TProp extends string,
-  TOp extends ComparatorOperation
-> = TList extends unknown[]
-? SingleFilter<TList, TComparator, TProp, TOp>
-: // readonly only tuples
-  TList extends readonly unknown[]
-    ? Readonly<
-        SingleFilter<[...TList], TComparator, TProp, TOp>
-      >
-    : never;
-
-
-/**
- * **RetainByProp**`<TList, TComparator, TProp, [TOp]>`
- *
- * Allows a known tuple `TList` to be reduced to a subset with the value `TComparator`
- * being compared to each element in TList[TProp]; if comparison resolves to a `true`
- * value then the element `TList[TProp]` is preserved
- * but otherwise removed.
- *
- * - How the list is _compared_ depends on `TOp` which defaults to "extends"
- * - other values include "equals", "does-not-extend", "does-not-equal"
- *
- * By default `TOp` is set to _extends_ which ensures that those values in the list which
- * _extend_ `TValue` are retained but the remaining filtered out.
- *
- * ```ts
- * type T = [1,"foo",3];
- * // [1,3]
- * type T2 = Filter<T, string>;
- * ```
- * - `TComparator` can be single value or a Tuple of values
- * - in the case of a Tuple of values being found in `TComparator`, an "OR" operation
- * will be used ... meaning that the elements in `TList` will be kept if an element
- * extends _any_ of the `TFilter` entries
- * - any non-container based value in `TList` will be discarded
- *
- * **Related:** `FilterByProp`, `Filter`, `RetainFromList`, `RemoveFromList`
- */
-export type RetainByProp<
-  TList extends readonly unknown[],
-  TComparator,
-  TProp extends string,
-  TOp extends ComparatorOperation = "extends"
-> = IsDotPath<TProp> extends false
-? Throw<"invalid-dot-path", `the property value TProp must be a valid dotpath but "${TProp}" is not valid!`>
-
-: TList extends readonly unknown[]
-? IfNever<
-    TComparator,
-    RemoveNever<TList>,
-    If<
-      IsArray<TComparator>,
-      Process<
-        TList,
-        TupleToUnion<TComparator>,
-        TProp,
-        TOp
-      >,
-      Process<
-        TList,
-        TComparator,
-        TProp,
-        TOp
-      >
-    >
-  >
-: never;

package/src/types/lists/RetainLiterals.ts

@@ -1,30 +0,0 @@
-import { Constant } from "inferred-types/dist/constants/index";
-import { IsLiteral } from "../boolean-logic";
-import { If } from "../boolean-logic/branching/If";
-import { RemoveMarked } from "../containers";
-
-type Process<
-T extends readonly unknown[]
-> = RemoveMarked<{
-[K in keyof T]: If<
-  IsLiteral<T[K]>,
-  T[K],
-  Constant<"Marked">
->
-}>
-
-/**
- * **RetainLiterals**`<T>`
- *
- * Receives a tuple of items and keeps only the literal types
- * (e.g., object, number, string, Record<string, string>, boolean, etc.).
- *
- * All literal types and elements such as _undefined_ and `null` are removed.
- *
- * **Related:** `Retain`, `FilterLiterals`, `RetainWideTypes`
- */
-export type RetainLiterals<
-  T extends readonly unknown[]
-> = Process<T> extends readonly unknown[]
-? Process<T>
-: never;

package/src/types/lists/RetainWideTypes.ts

@@ -1,31 +0,0 @@
-import { Constant } from "inferred-types/dist/constants/index";
-import { IsWideType } from "../boolean-logic";
-import { If } from "../boolean-logic/branching/If";
-import { RemoveMarked } from "../containers";
-
-type Process<
-T extends readonly unknown[]
-> = RemoveMarked<{
-  [K in keyof T]: If<
-    IsWideType<T[K]>,
-    T[K],
-    Constant<"Marked">
->
-}>
-
-/**
- * **RetainWideTypes**`<T>`
- *
- * Receives a tuple of items and keeps only the "wide types"
- * (e.g., object literals, tuple literals, string literals,
- * numeric literals, and boolean literals).
- *
- * All wide types and elements such as _undefined_ and `null` are removed.
- *
- * **Related:** `Retain`, `RetainLiterals`, `FilterWideTypes`
- */
-export type RetainWideTypes<
-  T extends readonly unknown[]
-> = Process<T> extends readonly unknown[]
-? Process<T>
-: never;