inferred-types 0.51.1 → 0.51.2

package/src/types/lists/ReturnTypes.ts

@@ -1,20 +0,0 @@
-import { TypedFunction } from "inferred-types/dist/types/index";
-
-/**
- * **ReturnTypes**`<T>`
- *
- * Given any Tuple, this utility will return a _union_ type
- * that represents all the possible _return types_ from functions found
- * in the array. Non-function types will be ignored as will functions
- * which don't return a boolean value.
- *
- * **See Also**: `LogicalReturns` and `TruthyReturns`
- */
-export type ReturnTypes<T extends readonly unknown[]> = {
-  [K in keyof T]: T[K] extends TypedFunction
-    ? ReturnType<T[K]> extends boolean
-      ? ReturnType<T[K]>
-      : never
-    : never;
-};
-

package/src/types/lists/Reverse.ts

@@ -1,14 +0,0 @@
-import { AfterFirst , First } from "inferred-types/dist/types/index";
-
-type RevAcc<
-  TInput extends readonly unknown[],
-  TResults extends readonly unknown[] = []
-> = [] extends TInput
-  ? TResults
-  : RevAcc<
-      AfterFirst<TInput>,
-      [ First<TInput>, ...TResults ]
-    >;
-
-export type Reverse<T extends readonly unknown[]> = RevAcc<T>;
-

package/src/types/lists/Second.ts

@@ -1,22 +0,0 @@
-
-
-/**
- * **Second**`<T, [ELSE]>`
- * 
- * Returns the _second_ type in a list. If `TElse` is provided it will set 
- * the type to `TElse` when:
- * - `T` is a Tuple type
- * - `T[1]` is not a valid index of `T`
- * - by default `TElse` is set to _never_
- * 
- * **Related:** `First`, `Last`
-*/
-export type Second<
-  T,
-  ELSE = never
-> = T extends readonly unknown[]
-  ? T[1] extends T[number]
-      ? T[1]
-      : ELSE
-  : never;
-

package/src/types/lists/Shift.ts

@@ -1,50 +0,0 @@
-import {
-  Tuple,
-  AsString,
-  AsArray,
-  Concat,
-  IsStringLiteral,
-  If,
-  Chars,
-  IsUndefined
-} from "inferred-types/dist/types/index";
-
-type _Shift<TList extends Tuple> = //
-TList extends [unknown, ...(infer Tail)]
-  ? Tail
-  : undefined;
-
-type _ShiftChar<TList extends Tuple> = //
-TList extends [unknown, ...(infer Tail)]
-  ? Tail
-  : never;
-
-
-/**
- * **Shift**`<T>`
- *
- * Removes the first element of a list, returning the rest.
- * ```ts
- * // [2,3]
- * type T = Shift<[1,2,3]>;
- * ```
- *
- * - to provide additional utility, you can also pass
- * in a string literal and get back the literal with the first
- * character removed.
- * - if there is nothing left in Tuple or an empty string is passed in as input
- * then the output will _undefined_.
- */
-export type Shift<
-  T extends undefined | string | Tuple
-> = IsUndefined<T> extends true
-? undefined
-:T extends Tuple
-? _Shift<AsArray<T>>
-: If<
-    IsStringLiteral<T>,
-      _Shift<AsArray<Chars<AsString<T>>>> extends readonly string[]
-    ? Concat<_Shift<AsArray<Chars<AsString<T>>>>>
-    : undefined,
-    string
-  >;

package/src/types/lists/Slice.ts

@@ -1,133 +0,0 @@
-
-import {
-  As,
-  Add,
-  Chars,
-  Concat,
-  FixedLengthArray,
-  IsPositiveNumber,
-  Throw,
-  If,
-  IsNumericLiteral,
-  IsGreaterThan,
-  IsGreaterThanOrEqual,
-  TakeFirst,
-  IsNegativeNumber,
-  Abs,
-} from "inferred-types/dist/types/index";
-
-export type RemoveStart<
-  TList extends readonly unknown[],
-  TStart extends number,
-> = TStart extends 0
-? TList
-: IsPositiveNumber<TStart> extends true
-  ? TList extends [
-      ...FixedLengthArray<unknown, TStart>,
-      ...(infer REST)
-    ]
-      ? REST
-      : Throw<"invalid-start-index">
-: TList extends [
-    ...FixedLengthArray<unknown, Add<TList["length"], TStart>>,
-    ...(infer REST)
-  ]
-    ? REST
-    : Throw<"invalid-start-index">;
-
-export type TruncateAtLen<
-  TList extends readonly unknown[],
-  TLen extends number
-> = IsNegativeNumber<TLen> extends true
-? If<
-    IsGreaterThan<Abs<TLen>, TList["length"]>,
-    never,
-    TakeFirst<TList, Add<TList["length"],TLen>>
-  >
-: If<
-    IsGreaterThanOrEqual<TLen, TList["length"]>,
-    TList,
-    TakeFirst<TList, TLen>
-  >;
-
-
-
-export type Process<
-  TList extends readonly unknown[],
-  TStart extends number,
-  TLen extends number | undefined
-> = TList extends readonly unknown[]
-? RemoveStart<
-    TList,
-    TStart
-  > extends readonly unknown[]
-    ? If<
-        IsNumericLiteral<TLen>,
-        TruncateAtLen<
-          RemoveStart<
-            TList,
-            TStart
-          >,
-          As<TLen, number>
-        >,
-        // no length specified
-        RemoveStart<
-          TList,
-          TStart
-        >
-      >
-
-
-    : RemoveStart<
-        TList,
-        TStart
-      >
-: never
-
-type PreProcess<
-TList extends readonly unknown[],
-TStart extends number,
-TLen extends number | undefined = undefined,
-> = TList extends string
-? Chars<TList> extends readonly string[]
-? Concat<
-    As<
-      Process<
-        Chars<TList>,
-        TStart,
-        TLen
-      >,
-      readonly string[]
-    >
-  >
-: never
-: TList extends readonly unknown[]
-? Process<TList,TStart,TLen>
-: never;
-
-
-/**
- * **Slice**`<TList, TStart, TLen>`
- *
- * Provides a slice of a tuple or a string.
- *
- * - negative indexes for `TEnd` can be used
- * - `TStart` defaults to 0
- * - `TLen` defaults to the all the remaining elements
- * but can be any amount; if you use negative values this
- * will drop that many values off the end of the tuple
- */
-export type Slice<
-  TList extends readonly unknown[] | string,
-  TStart extends number,
-  TLen extends number | undefined = undefined,
-> = TList extends string
-? Concat<As<PreProcess<Chars<TList>, TStart, TLen>, readonly string[]>>
-: TList extends readonly unknown[]
-? PreProcess<TList, TStart, TLen> extends readonly unknown[]
-? PreProcess<TList, TStart, TLen>
-: never
-: never;
-
-
-

package/src/types/lists/TakeFirst.ts

@@ -1,67 +0,0 @@
-import {
-  IsGreaterThan,
-  If,
-  Throw,
-  IsEqual,
-  AfterFirst,
-  Increment,
-  First,
-  IsGreaterThanOrEqual
-} from "inferred-types/dist/types/index";
-
-
-type Process<
-  TContent extends readonly unknown[],
-  TLen extends number,
-  TIdx extends number = 0,
-  TResult extends readonly unknown[] = []
-> = [] extends TContent
-? TResult
-: If<
-    IsGreaterThanOrEqual<TIdx,TLen>,
-    TResult,
-    Process<
-      AfterFirst<TContent>,
-      TLen,
-      Increment<TIdx>,
-      [
-        ...TResult,
-        First<TContent>
-      ]
-    >
-  >;
-
-
-
-
-/**
- * **TakeFirst**`<TContent,TLen,[THandle]>`
- *
- * Takes the first `TLen` items from `TContent` and discards the rest.
- *
- * Note:
- * - by default if `TLen` is larger than the size of `TContent` this
- * is fine and instead of getting precisely `TLen` elements you'll get
- * `TLen` element when available otherwise just the full tuple length
- * of `TContent`
- * - if you want a precise length, then set `THandle` to "throw" and
- * an error will be thrown.
- */
-export type TakeFirst<
-  TContent extends readonly unknown[],
-  TLen extends number,
-  THandle extends "ignore" | "throw" = "ignore"
-> = If<
-  IsGreaterThan<TLen, TContent["length"]>,
-  // TLen greater than TContent length
-  If<
-    THandle extends "ignore" ? true : false,
-    TContent,
-    Throw<"invalid-length", `TakeFirst<TContent,TLen> was called where the length of TLen(${TLen}) was greater than the length of the content (${TContent["length"]})!`>
-  >,
-  If<
-    IsEqual<TLen, TContent["length"]>,
-    TContent,
-    Process<TContent,TLen>
-  >
->;

package/src/types/lists/TakeLast.ts

@@ -1,31 +0,0 @@
-
-
-import {
-  TakeFirst,
-  Reverse
-} from "inferred-types/dist/types/index";
-
-
-
-/**
- * **TakeLast**`<TContent,TLen,[THandle]>`
- *
- * Takes the last `TLen` items from `TContent` and discards the rest.
- *
- * Note:
- * - by default if `TLen` is larger than the size of `TContent` this
- * is fine and instead of getting precisely `TLen` elements you'll get
- * `TLen` element when available otherwise just the full tuple length
- * of `TContent`
- * - if you want a precise length, then set `THandle` to "throw" and
- * an error will be thrown.
- */
-export type TakeLast<
-  TContent extends readonly unknown[],
-  TLen extends number,
-  THandle extends "ignore" | "throw" = "ignore"
-> = TakeFirst<
-  Reverse<TContent>,
-  TLen,
-  THandle
->;

package/src/types/lists/ToCSV.ts

@@ -1,29 +0,0 @@
-import { AfterFirst, AsString, First, Replace, StripLeading, Tuple } from "inferred-types/dist/types/index";
-
-type Process<
-  T extends Tuple,
-  TReplace extends string,
-  TResult extends string = ""
-> = [] extends T
-? StripLeading<TResult, ",">
-: Process<
-    AfterFirst<T>,
-    TReplace,
-    First<T> extends string
-      ? `${TResult},${Replace<First<T>, ",", TReplace>}`
-      : `${TResult},${AsString<First<T>>}`
-    >;
-
-
-/**
- * **ToCSV**`<TTuple,[TReplace]>`
- *
- * Converts a tuple into a CSV string. For any elements
- * in the tuple which are strings the `,` character will
- * be replaced with the value of `TReplace` (which defaults
- * to `<comma>`).
- */
-export type ToCSV<
-  TTuple extends Tuple,
-  TReplace extends string = "<comma>"
-> = Process<TTuple, TReplace>;

package/src/types/lists/TruthyReturns.ts

@@ -1,23 +0,0 @@
-import {  If, IsTruthy , TupleToUnion, TypedFunction } from "inferred-types/dist/types/index";
-
-/**
- * **TruthyReturns**`<T>`
- *
- * Given a known Tuple, this utility will return a _union_ type
- * that represents the _[truthiness](https://frontend.turing.edu/lessons/module-1/js-truthy-falsy-expressions.html)_
- * of each element; where:
- *
- * - functions are evaluated by their _return type_
- * - non-functions are evaluated directly
- *
- * **Note:** `true` and `false` will be returned where possible but in cases where
- * a type can't be evaluated at design time then `boolean` will be returned.
- *
- * **See Also**: `ReturnTypes` and `LogicalReturns`
- */
-export type TruthyReturns<T extends readonly unknown[]> = TupleToUnion<{
-  [K in keyof T]: //
-    T[K] extends TypedFunction
-      ? If<IsTruthy<ReturnType<T[K]>>, true, false, boolean>
-      : If<IsTruthy<T[K]>, true, false, boolean>;
-}>;

package/src/types/lists/UnionFromProp.ts

@@ -1,26 +0,0 @@
-import { Narrowable, Get } from "inferred-types/dist/types/index";
-
-/**
- * **UnionFromProp**
- *
- * Given an array of objects `<T>` and a property value `<P>`, this utility will
- * return a _union type_ of all the potential values of the objects which have
- * a keyof `P`.
- *
- * If an object in the array _explicitly_ doesn't have the prop in it's definition then it
- * is ignored, if it is shaped to be an optional property then `undefined` will be included
- * in the union.
- *
- * ```ts
- * const data = [
- *    { id: 123, color: "blue" },
- *    { id: 456, color: "red" },
- *  ] as const;
- * // 123 | 456
- * type U = UnionFromProp<typeof data, "id">;
- * ```
- */
-export type UnionFromProp<
-  T extends readonly Record<string, Narrowable>[],
-  P extends string
-> = Readonly<Get<T[number], P>>;

package/src/types/lists/index.ts

@@ -1,61 +0,0 @@
-// #autoindex
-
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: 582c0cf0
-
-// file exports
-export * from "./AfterFirst";
-export * from "./AllowNonTupleWhenSingular";
-export * from "./ArrayElementType";
-export * from "./First";
-export * from "./Second";
-export * from "./AsArray";
-export * from "./AsTuple";
-export * from "./ElementOf";
-export * from "./FirstString";
-export * from "./Filter";
-export * from "./FilterByProp";
-export * from "./FilterLiterals";
-export * from "./FilterWideTypes";
-export * from "./Length";
-export * from "./Last";
-export * from "./MaxLength";
-export * from "./IndexOf";
-export * from "./UnionFromProp";
-export * from "./Flatten";
-export * from "./Reverse";
-export * from "./Retain";
-export * from "./RetainByProp";
-export * from "./RetainLiterals";
-export * from "./RetainWideTypes";
-export * from "./Find";
-export * from "./Slice";
-export * from "./Last";
-export * from "./TruthyReturns";
-export * from "./ReturnTypes";
-export * from "./LogicalReturns";
-export * from "./Intersect";
-export * from "./IntersectAll";
-export * from "./Filter";
-export * from "./NumericKeys";
-export * from "./ConvertAndMap";
-export * from "./ConvertAndMap";
-export * from "./ConvertSet";
-export * from "./Pop";
-export * from "./Shift";
-export * from "./ReplaceLast";
-export * from "./BeforeLast";
-export * from "./GetEach";
-export * from "./ToCSV";
-export * from "./Push"
-export * from "./TakeFirst"
-export * from "./TakeLast"
-export * from "./NumericSort"
-export * from "./AsNumericArray";
-
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/src/types/literals/BooleanLike.ts

@@ -1,9 +0,0 @@
-
-
-/**
- * **BooleanLike**
- *
- * A union of all boolean types plus the string literal representations of these
- * literals.
- */
-export type BooleanLike = boolean | "true" | "false" | "boolean";

package/src/types/literals/Box.ts

@@ -1,20 +0,0 @@
-
-import { HasParameters, TypedFunction } from "inferred-types/dist/types/index";
-
-export interface Box<T> {
-  __type: "box";
-  value: T;
-  /**
-   * Unbox the boxed value in the narrowest possible type.
-   *
-   * **note:** if the boxed value is a function with parameters you
-   * can pass the parameters directly into the `b.unbox(params)` call.
-   */
-  unbox: HasParameters<Box<T>["value"]> extends true
-    ? Box<T>["value"] extends TypedFunction
-      ? Box<T>["value"] extends (...args: infer A) => infer R
-        ? <N extends A>(...args: N) => R
-        : () => ReturnType<T>
-      : () => T
-    : () => T;
-}