inferred-types 0.51.1 → 0.51.3

package/src/types/tsconfig.json

@@ -1,51 +0,0 @@
-{
-  "references": [
-    {
-      // depends on constants to derive some types
-      "path": "../constants"
-    }
-  ],
-  "compilerOptions": {
-    "strict": true,
-    "skipLibCheck": true,
-    "module": "ES2022",
-    "target": "ES2022",
-    "moduleResolution": "node",
-    "declaration": true,
-    "declarationMap": true,
-    "baseUrl": ".",
-    "rootDir": "..",
-    "outDir": "../../dist",
-    "composite": true,
-    "forceConsistentCasingInFileNames": true,
-    "paths": {
-      // allow importing from the root export of the types sub project
-      "src/types/index": [
-        "index.ts"
-      ],
-      "inferred-types/dist/runtime/index": [
-        "../runtime/index.ts"
-      ],
-      "inferred-types/dist/types/index": [
-        "index.ts"
-      ],
-      "inferred-types/dist/constants/index": [
-        "../constants/index.ts"
-      ],
-      // allow importing all constants to the static "src/constants/index" path
-      "src/constants/index": [
-        "../constants/index.ts"
-      ],
-      "inferred-types": [
-        "../constants/index.ts"
-      ],
-      // allow various "index.ts" to import explicit files in the src tree
-      "src/types/*": [
-        "./*"
-      ]
-    },
-  },
-  "include": [
-    "./**/*.ts"
-  ]
-}

package/src/types/tuples/DictArray.ts

@@ -1,21 +0,0 @@
-/* eslint-disable no-use-before-define */
-export type DictArrayFilterCallback<K extends keyof T, T extends object, R extends true | false> = (key: K, value: Pick<T, K>) => R;
-
-/**
- * An element in a `DictArray` shaped as a two element tuple: `[key, kv]`.
- */
-export type DictArrayKv<K extends keyof T, T> = [K, Pick<T, K>];
-
-export type DictKvTuple<K extends string> = [K, Record<K, unknown>];
-
-/**
- * A an array of `DictArrayKv` tuples which can be reconstructed
- * to a strongly typed dictionary object.
- * ```ts
- * const example: DictArray<{ foo: 1, bar: "hi" }> = [
- *   [ "foo", { foo: 1 }],
- *   [ "bar", { bar: "hi" }]
- * ]
- * ```
- */
-export type DictArray<T> = Array<{ [K in keyof T]: DictArrayKv<K, T> }[keyof T]>;

package/src/types/tuples/FirstKey.ts

@@ -1,16 +0,0 @@
-import {  Dictionary, Keys , Tuple, UnionToTuple } from "inferred-types/dist/types/index";
-
-/**
- * Returns the _first_ key in an object.
- *
- * **Note:** key order is not guaranteed so typically this is used
- * for a key/value pair where only one key is expected
- */
-export type FirstKey<T extends Dictionary | Tuple> = T extends Tuple
-? T extends [infer First extends unknown , ...unknown[]]
-  ? First
-  : never
-
-: UnionToTuple<Keys<T>> extends readonly unknown[]
-  ? UnionToTuple<Keys<T>>[0]
-  : never;

package/src/types/tuples/FirstKeyValue.ts

@@ -1,10 +0,0 @@
-import {  Dictionary } from "inferred-types/dist/types/index";
-import { FirstKey } from "./FirstKey";
-
-/**
- * Utility type which operates on a dictionary and provides the **value** of the
- * `First<T>` key of the dictionary. Because dictionary's don't provide assurances
- * about key order, this is typically only used in cases where it's known there is
- * a single key on the object.
- */
-export type FirstKeyValue<T extends Dictionary> = FirstKey<T> extends keyof T ? T[FirstKey<T>] : never;

package/src/types/tuples/FirstOfEach.ts

@@ -1,16 +0,0 @@
-/**
- * **FirstOfEach**`<TList>`
- * 
- * Expects `TList` to consist of an array of arrays and then this utility will reduce
- * this to a _tuple_ of all the first elements in `TList`.
- *
- * ```ts
- * // ["foo", "bar"]
- * type A = FirstOfEach<[ ["foo", 1], ["bar", 2] ]>;
- * ```
- */
-export type FirstOfEach<
-  T extends readonly unknown[][]
-> = T[number][0] extends T[number][number]
-  ? T[number][0]
-  : never;

package/src/types/tuples/FixedLengthArray.ts

@@ -1,28 +0,0 @@
- 
-type Shift<A extends Array<any>> = 
-  ((...args: A) => void) extends ((...args: [A[0], ...infer R]) => void) ? R : never;
-
-type GrowExpRev<A extends any[], N extends number, P extends any[][]> = 
-  A["length"] extends N ? A : [...A, ...P[0]][N] extends undefined ? GrowExpRev<[...A, ...P[0]], N, P> : GrowExpRev<A, N, Shift<P>>;
-
-type GrowExp<A extends any[], N extends number, P extends any[][], L extends number = A["length"]> = 
-  L extends N ? A : L extends 8192 ? any[] : [...A, ...A][N] extends undefined ? GrowExp<[...A, ...A], N, [A, ...P]> : GrowExpRev<A, N, P>;
-
-type MapItemType<T, I> = { [K in keyof T]: I };
-
-type Process<
-  T,
-  N extends number
-> = N extends 0 
-? [] 
-: MapItemType<GrowExp<[0], N, []>, T>;
-
-/**
- * **FixedLengthArray**`<T,N>`
- * 
- * Creates a fixed length `<N>` array of a given type `<T>`
- */
-export type FixedLengthArray<T, N extends number> = 
-Process<T,N> extends readonly unknown[]
-  ? Process<T,N>
-  : never;

package/src/types/tuples/FromDictArray.ts

@@ -1,13 +0,0 @@
-import { ExpandRecursively , UnionToIntersection } from "inferred-types/dist/types/index";
-
-/**
- * Typescript utility which receives `T` as shape which resembles `DictArray<D>`
- * and if the type `D` can be inferred it is returned.
- * ```ts
- * // { foo: 1; bar: "hi" }
- * type Dict = FromDictArray<[["foo", { foo: 1 }], ["bar", { bar: "hi" }]]>;
- * ```
- */
-export type FromDictArray<T extends [string, Record<string, unknown>][]> = ExpandRecursively<
-  UnionToIntersection<T[number][1]>
->;

package/src/types/tuples/LastOfEach.ts

@@ -1,21 +0,0 @@
-import {  Last } from "inferred-types/dist/types/index";
-
-/**
- * **LastOfEach**`<TList>`
- *
- * Expects `TList` to consist of an array of arrays and then this utility will reduce
- * this to a _tuple_ of all the _last_ elements in `TList`
- *
- * ```ts
- * // [1, 2]
- * type A = LastOfEach<[ ["foo", 1], ["bar", 2] ]>;
- * ```
- */
-export type LastOfEach<
-  T extends readonly unknown[][]
-> = {
-  [K in keyof T]: T[K] extends readonly unknown[]
-    ? Last<T[K]>
-    : never
-}
-

package/src/types/tuples/SecondOfEach.ts

@@ -1,13 +0,0 @@
-
-/**
- * For a two-dimensional array, returns a _union type_ which combines the first element of the interior
- * array.
- * 
- * ```ts
- * // 1 | 2
- * type F = SecondOfEach<[ ["foo", 1], ["bar", 2] ]>;
- * ```
- */
-export type SecondOfEach<T extends unknown[][]> = T[number][1] extends T[number][number]
-  ? T[number][1]
-  : never;

package/src/types/tuples/index.ts

@@ -1,19 +0,0 @@
-// #autoindex
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: 582cd3f6
-
-// file exports
-export * from "./DictArray";
-export * from "./FirstKey";
-export * from "./FirstKeyValue";
-export * from "./FirstOfEach";
-export * from "./LastOfEach";
-export * from "./FromDictArray";
-export * from "./FixedLengthArray";
-export * from "./SecondOfEach";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

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

@@ -1,16 +0,0 @@
-
-/**
- * **AsBoolean**`<T>`
- *
- * Converts any `BooleanLike` value to a boolean value
- * and return `never` otherwise.
- */
-export type AsBoolean<T> = T extends boolean
-  ? T
-  : T extends "true"
-  ? true
-  : T extends "false"
-  ? false
-  : T extends "boolean"
-  ? boolean
-  : never;

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

@@ -1,17 +0,0 @@
-import { Dictionary } from "../base-types/Dictionary";
-
-
-/**
- * **AsContainer**`<T, [TError]>`
- * 
- * Returns `T` with the type that ensures it is a
- * container. 
- */
-export type AsContainer<
-  T,
-  TError = never
-> = T extends readonly unknown[]
-  ? T & readonly unknown[]
-  : T extends Dictionary
-    ? T & Dictionary
-    : TError;

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

@@ -1,8 +0,0 @@
-
-/**
- * **AsDefined**`<T>`
- * 
- * Ensures that if `T` includes _undefined_ as part of a union, it is
- * removed.
- */
-export type AsDefined<T> = Exclude<T, undefined>;

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

@@ -1,5 +0,0 @@
-import { Dictionary } from "../base-types";
-
-export type AsDictionary<T> = T extends Dictionary
-  ? T
-  : never;

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

@@ -1,14 +0,0 @@
-
-
-/**
- * **AsFunction**<TTest, [TParams]>
- * 
- * Attempts to narrow `T` to a string type where possible.
- * 
- * **Related:** `ToString`
- */
-export type AsFunction<
-  TTest,
-  TParams extends readonly unknown[] = readonly unknown[]
-> = TTest & (<TArgs extends TParams>(args: TArgs) => unknown);
-

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

@@ -1,38 +0,0 @@
-import { If, IsEqual, IsUnion } from "../boolean-logic";
-import { Throw } from "../errors";
-import { Filter } from "../lists/Filter";
-import { TupleToUnion } from "./TupleToUnion";
-import { UnionToTuple } from "./UnionToTuple";
-
-type InvalidCast<T> = Throw<
-  "invalid-cast",
-  `An attempt to cast a type as being non-null based was unsuccessful!`,
-  "AsNonNull",
-  {library: "inferred-types"; value: T}
->
-
-/**
- * **AsNonNull**`<T>`
- * 
- * A narrowing utility which ensures that a union type which includes a `null`
- * option will have the **null** option removed.
- * 
- * **Note:** if `T` is _equal to **null** then an `ErrorCondition<"invalid-cast">`
- * will be raised.
- */
-export type AsNonNull<T> = If<
-  IsEqual<T, null>,
-  InvalidCast<T>,
-  IsUnion<T> extends true
-    ? TupleToUnion<Filter<UnionToTuple<T>, null>>
-    : T
-> extends null 
-? never
-: If<
-    IsEqual<T, null>,
-    InvalidCast<T>,
-    IsUnion<T> extends true
-      ? TupleToUnion<Filter<UnionToTuple<T>, null>>
-      : T
-    >
-

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

@@ -1,29 +0,0 @@
-
-/**
- * **ParseInt**`<T>`
- *
- * Converts a known string literal representation of a number
- * to an actual number.
- */
-export type ParseInt<T> = T extends `${infer N extends number}`
-  ? N
-  : never;
-
-
-/**
- * **AsNumber**`<T>`
- *
- * Returns a _number_ for `T` where `T` extends a _number_ or `${number}` type; otherwise
- * return _never_. Literal types are preserved.
- *
- * ```ts
- * // 4
- * type Num = AsNumber<"4">;
- * ```
- * **Related:** `ToNumber`
- */
-export type AsNumber<T> = T extends number
-  ? T
-  : T extends `${number}`
-      ? ParseInt<T>
-      : never;

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

@@ -1,6 +0,0 @@
-
-
-
-export type AsObject<T> = T extends object
-? T
-: never;

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

@@ -1,21 +0,0 @@
-import { ObjectKey } from "inferred-types/dist/types/index";
-
-
-/**
- * **AsObjectKeys**`<T>`
- *
- * Narrows type by validating that `T` extends a tuple of only
- * values which extend `ObjectKey`.
- */
-export type AsObjectKeys<
-  T extends readonly unknown[]
-> = T extends readonly ObjectKey[]
-? T
-: never;
-
-/**
- * **AsObjectKey**`<T>`
- *
- * Narrows type by validating that `T` extends `ObjectKey`.
- */
-export type AsObjectKey<T> = T extends ObjectKey ? T : never;

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

@@ -1,11 +0,0 @@
-
-
-/**
- * **AsPropertyKey**`<T>`
- * 
- * Ensures that `T` is a property key or, if a tuple is passed in, that
- * all values extend `PropertyKey`
- */
-export type AsPropertyKey<T> = T extends PropertyKey
-  ? T 
-  : never;

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

@@ -1,21 +0,0 @@
-import { Dictionary, Tuple } from "../base-types";
-
-/**
- * **AsRecord**`<T>`
- * 
- * Receives a `Record`, `object`, or `Tuple` and ensures the type 
- * is a `Record` type for all object-like types and just passes 
- * Tuples through "as is".
- */
-export type AsRecord<
-  T extends Dictionary | object
-> = T extends Tuple
-? T
-: T extends Dictionary
-? T
-: T extends object
-   
-  ? T extends any[]
-    ? never
-    : NonNullable<unknown>
-  : never;

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

@@ -1,5 +0,0 @@
-import { Container } from "../base-types";
-
-export type AsRef<T> = T extends Container
-  ? T & { value: unknown }
-  : never;

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

@@ -1,28 +0,0 @@
-import { IsWideType } from "../boolean-logic";
-import { Join } from "../string-literals/Join";
-
-/**
- * **AsString**<T>
- *
- * Attempts to narrow `T` to a string type where possible.
- *
- * - will convert any string, boolean, or numeric value
- * to a string value
- * - union types which include a variant which is `T` can be
- *
- * **Related:** `ToString`
- */
-export type AsString<T> = T extends string
-  ? T & string
-  : T extends number
-  ? `${T}`
-  : T extends boolean
-  ? `${T}`
-  : string extends T
-  ? string
-  : T extends string[]
-  ? IsWideType<T> extends true
-    ? never
-    : Join<T>
-  :  never;
-

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

@@ -1,49 +0,0 @@
-import { IsUnion, TupleToUnion, UnionToTuple } from "inferred-types/dist/types/index";
-
-type ConvertUnion<
-  T extends readonly unknown[],
-  THandle extends "drop" | "proxy"
-> = TupleToUnion<{
-  [K in keyof T]: T[K] extends string
-    ? T[K]
-    : T[K] extends number
-    ? `${T[K]}`
-    : T[K] extends boolean
-    ? `${T[K]}`
-    : THandle extends "drop"
-      ? never
-      : T[K];
-}>
-
-/**
- * **AsStringUnion**`<T, [THandle]>`
- *
- * A type conversion utility which ensures unions (and a few literals) are
- * converted to string literal variants:
- *
- * - if `T` is a union type, all _numeric_ or _boolean_ elements in the union
- * will be converted to a string literal equivalent and others will be dropped
- * - if you would prefer non-convertible types are left as part of the union
- * you can set the `THandle` to "proxy" (instead of the default "drop")
- *
- * For non-union types, the goal is to address a similar outcome which is:
- *
- * - if `T` is of type `number` or `boolean` then this is converted to a
- * string literal equivalent
- * - all other types result in `never` or are just proxied through if
- * `THandle` is set to "proxy"
- */
-export type AsStringUnion<
-  T,
-  THandle extends "drop" | "proxy" = "drop"
-> = IsUnion<T> extends true
-? ConvertUnion<UnionToTuple<T>, THandle>
-: T extends string
-  ? T
-  : T extends number
-    ? `${T}`
-  : T extends boolean
-    ? `${T}`
-    : THandle extends "drop"
-      ? never
-      : T;

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

@@ -1,11 +0,0 @@
-/**
- * **Awaited**`<T>`
- * 
- * Unwraps the expected return value inside a promise-like
- * result.
- */
-export type Awaited<T> = T extends PromiseLike<infer Inner>
-  ? Inner
-  : never;
-
-  

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

@@ -1,24 +0,0 @@
-
-/**
- * **Break<T,D>**
- * 
- * Takes a string `T`, and splits it into a tuple of the form `[F, R]`.
- * ```ts
- * // ["the", " long and winding road"]
- * type T1 = Break<"the long and winding road", " ">;
- * // ["there", " I was, there I was"]
- * type T2 = Break<"there I was, there I was", " ">;
- * ```
- * 
- * **Related:** `Split`
- */
-export type Break<T extends string, D extends string> = (
-  string extends T ? [string, string] : (
-    T extends `${infer F}${D}${infer _R}` ? (
-      F extends `${infer _X}${D}${infer _Y}` ? never : (
-        T extends `${F}${infer R}` ? [F, R] : never
-      )
-    ) : [T, ""]
-  )
-);
-

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

@@ -1,21 +0,0 @@
-import { Filter } from "inferred-types/dist/types/index";
-
-/**
- * **IntersectWithAll**`<TList,TIntersection>`
- *
- * Type utility which iterates through each element of `TList` and intersects
- * the current value with `TIntersection`.
- *
- * - all intersections which evaluation to `never` are removed from the list
- * ```ts
- * type Arr = [1,2,"foo"];
- * // [1,2]
- * type Num = IntersectWithAll<Arr, number>;
- * ```
- */
-export type IntersectWithAll<
-  TList extends readonly unknown[],
-  TIntersection
-> = Filter<{
-  [K in keyof TList]: TList[K] & TIntersection
-}, never>;

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

@@ -1,40 +0,0 @@
-import { Tuple } from "../base-types";
-import { If, IsEqual } from "../boolean-logic";
-import { NumberLike } from "../numeric-literals";
-import { EnsureLeading, EnsureTrailing } from "../string-literals";
-import { AsNumber } from "./AsNumber";
-import { AsString } from "./AsString";
-
-
-/**
- * **JsonValue**`<T>`
- *
- * Converts a string value to the appropriate JSON type
- *
- * **Related:** `JsonValues`
- */
-export type JsonValue<T> = T extends NumberLike
-? AsNumber<T>
-: If<
-    IsEqual<T, "true">,
-    true,
-    If<
-      IsEqual<T, "false">,
-      false,
-      EnsureLeading<AsString<T>, "\""> extends string
-        ? EnsureTrailing<EnsureLeading<AsString<T>, "\"">, "\"">
-        : never
-    >
-  >
-
-/**
- * **JsonValues**`<T>`
- *
- * Converts a tuple of values to the appropriate JSON type
- *
- * **Related:** `JsonValue`
- */
-export type JsonValues<T extends Tuple> = {
-  [K in keyof T]: JsonValue<T[K]>
-}
-

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

@@ -1,19 +0,0 @@
-import { Replace } from "./Replace";
-import { TrimLeft } from "./TrimLeft";
-
-/**
- * Provides the _left_ whitespace of a string
- * ```ts
- * // "\n\t "
- * type T = LeftWhitespace<"\n\t foobar">;
- * ```
- */
-export type LeftWhitespace<S extends string> = string extends S
-  ? string
-  : Replace<
-      S, 
-      TrimLeft<S> extends string
-        ? TrimLeft<S>
-        : never, 
-      ""
-    >;