inferred-types 0.51.1 → 0.51.2

package/src/types/functions/RemoveFnProps.ts

@@ -1,11 +0,0 @@
-import { AnyFunction, AsFnMeta } from "inferred-types/dist/types/index";
-
-/**
- * **RemoveFnProps**`<T>`
- *
- * Takes a function `T` and returns the function unchanged but without any
- * key/value pairs that may have been added to the function's definition.
- */
-export type RemoveFnProps<
-  T extends AnyFunction
-> = (...args: AsFnMeta<T>["args"]) => AsFnMeta<T>["returns"];

package/src/types/functions/ToFn.ts

@@ -1,22 +0,0 @@
-import { AnyFunction, FnMeta, IsNever } from "inferred-types/dist/types/index";
-
-/**
- * **ToFn**`<T>`
- *
- * Ensures that resultant type is a function, where the mapping is:
- *
- *  - `AnyFunction` - function signature maintained
- *  - `FnMeta` - is converted to a precise function type
- *  - `never` _or_ `ErrorCondition` - returned "as is"
- *
- * All other values will return a function of the form `() => T`
- *
- * **Related:** `AsFn`
- */
-export type ToFn<T> = T extends AnyFunction
-    ? T
-    : T extends FnMeta<infer _Args, infer _Returns, infer Props, infer Fn>
-      ? IsNever<Props> extends true
-        ? Fn
-        : Fn & Props
-  : () => T

package/src/types/functions/TypeGuard.ts

@@ -1,9 +0,0 @@
-import { Narrowable } from "inferred-types/dist/types/index";
-
-/**
- * **TypeGuard**
- *
- * a typing for a **TS** type-guard which evaluates an _unknown_ input
- * and determines if it is of type `T`.
- */
-export type TypeGuard<T, U = Narrowable> = <UU extends U>(value: UU) => value is T & UU;

package/src/types/functions/WrapperFn.ts

@@ -1,40 +0,0 @@
-import { Container, TypedFunction } from "../base-types";
-import { If, IsUnset } from "../boolean-logic";
-import { Unset } from "../literals";
-import { FnFrom } from "./FnFrom";
-import { AsNarrowingFn } from "./NarrowingFn";
-
-
-/**
- * **WrapperFn**`<TFn,TTransform,[TState]>`
- *
- * A function which consumes a known function `TFn` and exposes the
- * same parameters externally while allowing it to _transform_ the
- * original functions return value before completing.
- *
- * Optionally, you can express some amount of _state_ which will be available
- * to the `TTransform` function to do it's work.
- *
- * ```ts
- * type Fn = (name: string) => `Hello ${string}`;
- * // (name: string) => `Hello ${name}!`;
- * type Wrapped = WrapperFn<Fn, v => `${v}!`>
- * ```
- */
-export type WrapperFn<
-  TFn extends TypedFunction,
-  TTransform extends <TRtn extends ReturnType<TFn>>(rtn: TRtn) => unknown,
-  TState extends Container | Unset = Unset
-> = If<
-  IsUnset<TState>,
-  FnFrom<
-    Parameters<TFn>,
-    ReturnType<AsNarrowingFn<TTransform>>
-  >,
-  <T extends TState>(state: T) => FnFrom<
-    Parameters<TFn>,
-    ReturnType<AsNarrowingFn<TTransform>>
-  >
->;
-
-

package/src/types/functions/index.ts

@@ -1,28 +0,0 @@
-// #autoindex
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: 57dfa865
-
-// file exports
-export * from "./LogicFunction";
-export * from "./TypeGuard";
-export * from "./AsFnMeta";
-export * from "./FnWithProps"
-export * from "./RemoveFnProps";
-export * from "./ToFn";
-export * from "./FnMeta";
-export * from "./FnFrom";
-export * from "./PromiseAll";
-export * from "./FnProps";
-export * from "./FnWithDescription";
-export * from "./HandleDoneFn"
-export * from "./NarrowingFn"
-export * from "./LiteralFn"
-export * from "./IdentityFn"
-export * from "./WrapperFn"
-// export * from "inferred-types/dist/types/index";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/src/types/index.ts

@@ -1,26 +0,0 @@
-// #autoindex
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: fbd4603a
-
-// file exports
-// directory exports
-export * from "./api/index";
-export * from "./base-types/index";
-export * from "./boolean-logic/index";
-export * from "./classes/index";
-export * from "./containers/index";
-export * from "./dictionary/index";
-export * from "./errors/index";
-export * from "./functional/index";
-export * from "./functions/index";
-export * from "./kv/index";
-export * from "./lists/index";
-export * from "./literals/index";
-export * from "./numeric-literals/index";
-export * from "./queues/index";
-export * from "./runtime-types/index";
-export * from "./sets/index";
-export * from "./string-literals/index";
-export * from "./tuples/index";
-export * from "./type-conversion/index";

package/src/types/kv/DictFromKv.ts

@@ -1,3 +0,0 @@
-export type DictFromKv<T extends readonly { key: string; value: unknown }[]> = {
-  [R in T[number] as R["key"]]: R["value"];
-};

package/src/types/kv/KeyValue.ts

@@ -1,12 +0,0 @@
-import { ExpandRecursively } from "inferred-types/dist/types/index";
-
-/**
- * Provides a strongly typed _key_ and _value_ for a dictionary `T`
- *
- * ```ts
- * type Obj = { foo: 1, bar: "hi" };
- * // ["foo", 1 ]
- * type Foo = KeyValue<Obj, "foo">;
- * ```
- */
-export type KeyValue<T extends object, K extends keyof T> = [K & keyof T, ExpandRecursively<T[K]>];

package/src/types/kv/KvFrom.ts

@@ -1,8 +0,0 @@
-/**
- * Type utility which takes an object type and converts to an array of KV objects:
- * ```ts
- * // [ {key: "id", value: 123 } | {key: "foo", value: "bar" } ][]
- * type Arr = KvFrom<{ id: 123, foo: "bar" }>;
- * ```
- */
-export type KvFrom<T extends object> = Array<{ [K in keyof T]: { key: K; value: T[K] } }[keyof T]>;

package/src/types/kv/KvTuple.ts

@@ -1,14 +0,0 @@
-/**
- * **KvTuple**
- * 
- * a key/value of type `T` represented as `[key, kv]`
- * 
- * ```ts
- * type Obj = { foo: 1, bar: "hi" };
- * // ["foo", { foo: 1 } ]
- * type Foo = KvTuple<Obj, "foo">;
- * ```
- * 
- * **Note:** _consider use of `KeyValue<T,K>` as an alternate representation_
- */
-export type KvTuple<T, K extends keyof T> = [K, Record<K, T[K]>];

package/src/types/kv/index.ts

@@ -1,15 +0,0 @@
-// #autoindex
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: 744ff3bf
-
-// file exports
-export * from "./DictFromKv";
-export * from "./KeyValue";
-export * from "./KvFrom";
-export * from "./KvTuple";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/src/types/lists/AfterFirst.ts

@@ -1,15 +0,0 @@
-import { Tuple } from "inferred-types/dist/types/index";
-
-/**
- * **AfterFirst**`<T>`
- *
- * returns the elements in an array _after_ the first element
- */
-export type AfterFirst<T extends Tuple > =
-  T extends readonly [unknown, ...unknown[]]
-  ? T extends readonly [unknown, ...infer Rest] ? readonly [...Rest] : never
-  : T extends unknown[]
-    ? []
-    : T extends [unknown, ...infer Rest]
-      ? Rest
-      : [];

package/src/types/lists/AllowNonTupleWhenSingular.ts

@@ -1,18 +0,0 @@
-import { ErrorCondition } from "inferred-types/dist/types/index";
-
-/**
- * **AllowNonTupleWhenSingular**`<TTuple>`
- *
- * Converts `T` to being `T | T[0]` when the tuple's length
- * is 1. Otherwise keeps the type as `T`.
- *
- * This type pairs well with the `AsArray` utility.
- */
-export type AllowNonTupleWhenSingular<
-  TTuple extends readonly unknown[]
-> = TTuple["length"] extends 1
-  ? TTuple[0] extends ErrorCondition
-    ? TTuple[0]
-    : TTuple | TTuple[0]
-  : TTuple;
-

package/src/types/lists/ArrayElementType.ts

@@ -1,17 +0,0 @@
-import { IsEmptyContainer, TupleToUnion, Widen } from "inferred-types/dist/types/index";
-
-/**
- * **ArrayElementType**`<T>`
- *
- * Determines what type the elements in an array are.
- * ```ts
- * // string
- * type T = ArrayElementType<string[]>;
- * ```
- */
-export type ArrayElementType<T extends readonly unknown[]> = IsEmptyContainer<T> extends true
-  // this is an array versus a known length array
-  ? [...T][0]
-  : Widen<TupleToUnion<T>>;
-
-

package/src/types/lists/AsArray.ts

@@ -1,24 +0,0 @@
-import { If,  IsUndefined,  Mutable, Tuple } from "inferred-types/dist/types/index";
-
-type _AsArray<T> = T extends Tuple
-    ? Mutable<T>
-    : If<
-        IsUndefined<T>,
-        [],
-        [T]
-      >;
-
-
-
-/**
- * **AsArray**`<T>`
- *
- * Type utility which ensures that `T` is an array by
- * encapsulating it as a single item array if it is a
- * non-array type.
- */
-export type AsArray<T> = _AsArray<T> extends any[]
-? _AsArray<T>
-: never;
-
-

package/src/types/lists/AsNumericArray.ts

@@ -1,21 +0,0 @@
-import { RemoveNever } from "../containers";
-import { NumberLike } from "../numeric-literals";
-import { AsNumber } from "../type-conversion";
-
-
-/**
- * **AsNumericArray**`<T>`
- *
- * Converts into a numeric array:
- *
- * - `number` values are proxied through
- * - `${number}` values are converted to a number
- * - all other types are converted to `never` and removed
- */
-export type AsNumericArray<T> = T extends readonly unknown[]
-? RemoveNever<{
-  [K in keyof T]: T[K] extends NumberLike
-    ? AsNumber<T[K]>
-    : never
-}>
-: never;

package/src/types/lists/AsReadonlyArray.ts

@@ -1,3 +0,0 @@
-export type AsReadonlyArray<T extends unknown[]> = T extends readonly[]
-  ? T
-  : readonly unknown[];

package/src/types/lists/AsTuple.ts

@@ -1,16 +0,0 @@
-import {  Tuple, If, IsUndefined } from "inferred-types/dist/types/index";
-
-/**
- * **AsTuple**`<T>`
- *
- * Type utility which ensures that `T` is tuple value
- * encapsulating it as a single item array if it is a
- * non-array type.
- *
- * **Related:** `AsArray`
- */
-export type AsTuple<T> = T extends Tuple
-    ? T
-    : T extends unknown[]
-      ? readonly [...T]
-      : If<IsUndefined<T>, readonly [], readonly [T]>;

package/src/types/lists/BeforeLast.ts

@@ -1,34 +0,0 @@
-import {  Chars, Concat, Handle, IsEqual, Pop, Tuple } from "inferred-types/dist/types/index";
-
-
-/**
- * **BeforeLast**`<T>`
- *
- * Returns:
- *
- * - the _elements_ in an **array**; _excluding_ the last element
- * - the _characters_ in a **string** excluding the last character
- *
- * This behavior is _very_ much like `Pop<T>` but where `Pop<T>` will
- * return _never_ when an empty input is passed in, this utility returns
- * the "empty" state:
- *
- * - a _tuple_ will return `[]`
- * - a _string_ will return ""
- *
- * **Related:** `Pop`, `Last`, `AfterFirst`, `First`
- */
-export type BeforeLast<
-  T extends Tuple | string
-> = T extends string
-  ? string extends T
-    ? string
-  : IsEqual<T, ""> extends true
-    ? ""
-    : Pop<Chars<T>> extends readonly string[]
-      ? Concat<Pop<Chars<T>>>
-      : never
-  : T extends Tuple
-    ? Handle<Pop<T>, never, []>
-    : never;
-

package/src/types/lists/ConvertAndMap.ts

@@ -1,138 +0,0 @@
-import { TupleToUnion, UnionToTuple , Narrowable , Keys, WithoutValue, First, AfterFirst, AnyObject, Tuple, Nothing } from "inferred-types/dist/types/index";
-
-
-// [Mapped Tuple Types](https://github.com/Microsoft/TypeScript/issues/25947)
-
-/**
- * **ConverterDefn**`<TStr,TNum,TBool,TObj,TTuple,TNothing>`
- *
- * A conversion definition which has wide types for keys and
- * callback functions to call when a particular type is provided
- * as input.
- */
-export type ConverterDefn<
-  TStr,
-  TNum,
-  TBool,
-  TObj,
-  TTuple,
-  TNothing
-> = {
-  string: <T extends string>(v: T) => TStr;
-  number: <T extends number>(v: T) => TNum;
-  boolean: <T extends boolean>(v: T) => TBool;
-  object: <T extends AnyObject>(v: T) => TObj;
-  tuple: <T extends Tuple>(v: T) => TTuple;
-  nothing: <T extends Nothing>(v: T) => TNothing;
-};
-
-type ConverterKeys<S, N, B, O> = UnionToTuple<
-  Keys<
-    WithoutValue<
-      {
-        string: S;
-        number: N;
-        boolean: B;
-        object: O;
-      },
-      undefined
-    >
-  >
->;
-
-type ConverterInputType<T extends string> = T extends "string"
-  ? string
-  : T extends "number"
-  ? number
-  : T extends "boolean"
-  ? boolean
-  : T extends "object"
-  ? Record<string, unknown>
-  : unknown;
-
-type ConverterInputUnion<
-  TConverted extends readonly unknown[],
-  TRemaining extends readonly string[]
-> = [] extends TRemaining
-  ? // we're done iterating
-    TConverted
-  : // recurse
-    ConverterInputUnion<
-      [...TConverted, ConverterInputType<First<TRemaining>>],
-      AfterFirst<TRemaining>
-    >;
-
-/**
- * **AvailableConverters**
- *
- * Type utility which will produce the correct union type for a "converter"
- */
-export type AvailableConverters<S, N, B, O> = ConverterKeys<S, N, B, O> extends readonly string[]
-  ? TupleToUnion<ConverterInputUnion<[], ConverterKeys<S, N, B, O>>>
-  : never;
-
-export type Conversion<TInput extends Narrowable, TOutput extends Narrowable> = <T extends TInput>(
-  input: T
-) => TOutput;
-
-export type ConverterCoverage = "string" | "number" | "boolean" | "object";
-
-/**
- * Extracts the coverage provided by a `StrongMap` as a Tuple
- */
-// eslint-disable-next-line no-use-before-define
-export type MapCoverage<T extends StrongMap<ConverterCoverage>> = T extends StrongMap<
-  infer Coverage
->
-  ? UnionToTuple<Coverage>
-  : never;
-
-export type StrongMapTypes<K extends readonly unknown[]> = [] extends K
-  ? never
-  : TupleToUnion<
-      [
-        First<K> extends "string"
-          ? TupleToUnion<[string, ...UnionToTuple<StrongMapTypes<AfterFirst<K>>>]>
-          : First<K> extends "number"
-          ? TupleToUnion<[number, ...UnionToTuple<StrongMapTypes<AfterFirst<K>>>]>
-          : First<K> extends "boolean"
-          ? TupleToUnion<[boolean, ...UnionToTuple<StrongMapTypes<AfterFirst<K>>>]>
-          : First<K> extends "object"
-          ? TupleToUnion<[Record<string, unknown>, ...UnionToTuple<StrongMapTypes<AfterFirst<K>>>]>
-          : never,
-        ...UnionToTuple<StrongMapTypes<AfterFirst<K>>>
-      ]
-    >;
-
-export type StrongMap<TDefined = ConverterCoverage> = {
-  string: TDefined extends "string" ? <T extends string, R>(v: T) => R : never;
-  number: TDefined extends "number" ? <T extends number, R>(v: T) => R : never;
-  boolean: TDefined extends "boolean" ? <T extends boolean, R >(v: T) => R : never;
-  object: TDefined extends "object"
-    ? <T extends Record<string, unknown>, R >(v: T) => R
-    : never;
-};
-
-export type StrongMapTransformer<M extends StrongMap> = <
-  T extends readonly StrongMapTypes<MapCoverage<M>>[]
->(
-  tuple: T
-) => {
-  [K in keyof T]: T[K] extends string
-    ? M["string"] extends (...args: unknown[]) => unknown
-      ? ReturnType<M["string"]>
-      : never
-    : T[K] extends number
-    ? M["number"] extends (...args: unknown[]) => unknown
-      ? ReturnType<M["number"]>
-      : never
-    : T[K] extends boolean
-    ? M["boolean"] extends (...args: unknown[]) => unknown
-      ? ReturnType<M["boolean"]>
-      : never
-    : T[K] extends Record<string, unknown>
-    ? M["object"] extends (...args: unknown[]) => unknown
-      ? ReturnType<M["object"]>
-      : never
-    : never;
-}[keyof T];

package/src/types/lists/ConvertSet.ts

@@ -1,44 +0,0 @@
-import { Narrowable , AfterFirst ,  First, Find } from "inferred-types/dist/types/index";
-
-export type ConversionTuple = [from: Narrowable, to: Narrowable];
-
-type Convert<
-  TValue,
-  TConversions extends readonly ConversionTuple[]
-> = Find<TConversions, "extends", TValue, 0> extends ConversionTuple
-  ? Find<TConversions, "extends", TValue, 0>[1]
-  : TValue;
-
-type ConvertAcc<
-  TSet extends readonly unknown[],
-  TConversions extends readonly ConversionTuple[],
-  TResults extends readonly unknown[] = []
-> = [] extends TSet
-  ? TResults
-  : ConvertAcc<
-      AfterFirst<TSet>,
-      TConversions,
-      [ ...TResults, Convert<First<TSet>, TConversions> ]
-    >;
-
-/**
- * **ConvertSet**`<TSet, TConversions>`
- *
- * Utility which works on a list `TSet` and converts matched values
- * to an alternative type.
- * ```ts
- * type List = ["abc", 123, null, "michael", undefined, "jackson"];
- * // ["abc", 123, "michael", "jackson"]
- * type Converted = ConvertSet<
- *    List, [ [null, never], [undefined, never] ]
- * >
- * ```
- */
-export type ConvertSet<
-  TSet extends readonly unknown[],
-  TConversions extends ConversionTuple | readonly ConversionTuple[]
-> = TConversions extends readonly ConversionTuple[]
-  ? ConvertAcc<TSet, TConversions>
-  : TConversions extends ConversionTuple
-    ? ConvertAcc<TSet, readonly [TConversions]>
-    : never;

package/src/types/lists/ElementOf.ts

@@ -1,7 +0,0 @@
-
-/**
- * **ElementOf**`<T>`
- *
- * Pulls the type of an array's element out of the array type itself.
- */
-export type ElementOf<T> = T extends (infer U)[] ? U : never;

package/src/types/lists/Filter.ts

@@ -1,86 +0,0 @@
-import {
-  ComparatorOperation,
-  Compare,
-  IsArray,
-  IfNever,
-  If,
-  TupleToUnion,
-  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> // filter out
-    : SingleFilter<Rest, TFilter, TOp, [...Result, Head]>
-  : Result;
-
-
-type Process<
-  TList extends unknown[] | readonly unknown[],
-  TFilter,
-  TOp extends ComparatorOperation
-> = TList extends unknown[]
-? SingleFilter<TList, TFilter, TOp>
-: // readonly only tuples
-  TList extends readonly unknown[]
-    ? Readonly<
-        SingleFilter<[...TList], TFilter, TOp>
-      >
-    : never;
-
-
-/**
- * **Filter**`<TList, TComparator, [TOp]>`
- *
- * Allows a known tuple `TList` to be reduced to a subset with the value `TFilter`:
- *
- * - How the list is reduced 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>;
- * ```
- * - `TFilter` can be single value or a Tuple of values
- * - in the case of a Tuple of values, an "OR" operation will be used ... meaning that
- * the elements in `TList` will be kept if an element extends _any_ of the `TFilter`
- * entries
- *
- * **Related:** `RetainFromList`, `RemoveFromList`
- */
-export type Filter<
-  TList extends readonly unknown[],
-  TComparator,
-  TOp extends ComparatorOperation = "extends"
-> = TList extends readonly unknown[]
-? IfNever<
-    TComparator,
-    RemoveNever<TList>,
-    If<
-      IsArray<TComparator>,
-      Process<
-        TList,
-        TupleToUnion<TComparator>,
-        TOp
-      >,
-      Process<
-        TList,
-        TComparator,
-        TOp
-      >
-    >
-  >
-: never;