inferred-types 0.36.4 → 0.37.1

package/src/runtime/valueTypes.ts

@@ -1,48 +0,0 @@
-import { Narrowable } from "src/types/Narrowable";
-
-export type ValueTuple = [type: any, narrowable: boolean];
-
-/**
- * An API surface for choosing a **type** which is defined for run-time
- * use but is translatable to the type system as well.
- */
-export type ValueTypes = {
-  string: [string, false];
-  boolean: [];
-};
-
-export const valueTypes = {
-  // WIDE
-  string: ["" as string, false] as [string, false],
-  boolean: [true as boolean, false] as [boolean, false],
-  number: [0 as number, false] as [number, false],
-  function: [(() => "") as Function, false] as [Function, false],
-  object: [{}, false] as [Record<string, any>, false],
-  array: <T extends any>(arr: T[] = [] as T[]) => [arr, false] as [T[], false],
-  null: [null, false] as [null, false],
-  symbol: [Symbol("type") as Symbol, false] as [Symbol, false],
-  undefined: [undefined, false] as [undefined, false],
-  // NARROW
-  true: [true as true, true] as [true, true],
-  false: [false as false, true] as [false, true],
-  /** pass in a literal type */
-  literal: <
-    N extends Narrowable,
-    T extends Record<any, N> | number | string | boolean | symbol | undefined | null
-  >(
-    v: T
-  ) => {
-    return [v as T, true] as [T, true];
-  },
-  literalArray: <
-    N extends Narrowable,
-    T extends Record<any, N> | number | string | boolean | symbol | undefined | null
-  >(
-    arr: T[]
-  ) => [arr, true],
-};
-
-export type ValueTypeFunc<
-  N extends Narrowable,
-  T extends Record<any, N> | number | string | boolean | symbol | null | Function
-> = (v: ValueTypes) => [T, boolean];

package/src/types/Api.ts

@@ -1,16 +0,0 @@
-export type ApiFunction<P extends any[], R extends any> = (...args: P) => R;
-export type FluentFunction<P extends any[], R extends any> = (...args: P) => R;
-export type ApiValue<V extends any> = V;
-
-/**
- * Expresses the API in a structured manner while making distinction
- * between a function endpoint and a _fluent_ function endpoint.
- */
-export type Api<T extends object> = {
-  [K in keyof T]: T[K] extends (...args: any) => T
-  ? FluentFunction<Parameters<T[K]>, ReturnType<T[K]>>
-  : T[K] extends (...args: any) => any
-  ? ApiFunction<Parameters<T[K]>, ReturnType<T[K]>>
-  : ApiValue<T[K]>
-};
-

package/src/types/Constructor.ts

@@ -1,5 +0,0 @@
-/**
- * Define a class constructor; allowing strong typing for constructor's parameters
- * and the returned class structure.
- */
-export type Constructor<Ctor extends any[], Klass extends any> = new (...props: Ctor) => Klass;

package/src/types/EnumValues.ts

@@ -1,14 +0,0 @@
-/**
- * Provides the values of an Typescript **enum**:
- * ```ts
- * enum Foo { foo, bar, baz };
- * // "0" | "1" | "2"
- * type NumerericEnum = EnumValues<Foo>;
- * enum Bar { foo = "foey", bar = "barred" };
- * // "foey" | "barred"
- * type StringEnum = EnumValues<Bar>;
- * ```
- *
- * **Note:** combine with `Numeric` to get number based indexes
- */
-export type EnumValues<T extends string | number> = `${T}`;

package/src/types/ExpandRecursively.ts

@@ -1,12 +0,0 @@
-
-/**
- * Recursively goes over an object based structure and tries to reduce
- * it down to just a simple key/value type.
- */
-export type ExpandRecursively<T> = T extends object
-  ? T extends (...args: any[]) => any
-    // Functions should be treated like any other non-object value
-    // but will/can identify as an object in JS
-    ? T
-    : { [K in keyof T]: ExpandRecursively<T[K]> }
-  : T;

package/src/types/FunctionType.ts

@@ -1,19 +0,0 @@
-/**
- * **FunctionType**
- *
- * Provides a way to correctly match for regular functions _and_ functions which
- * also have a dictionary hash alongside the root function.
- *
- * - without the generic `T` specified it simply matches correctly on both plain functions as well as functions which also have properties on them (this is consistent to how runtime's `typeof` operator works)
- * - with the generic you can specify the shape of the key/values
- */
-export type FunctionType<T extends {} = {}> = {} extends T
-  ? Function | (Function & { [key: string]: any })
-  : Function | (Function & T);
-
-/**
- * **FnShape**
- *
- * Simple way to express the shape of a function's arguments and return type.
- */
-export type FnShape<A extends any[] = any[], R extends any = any> = (...args: A) => R;

package/src/types/If.ts

@@ -1,10 +0,0 @@
-/**
- * Provides a unary condition for the type system:
- * ```ts
- * // "a"
- * type T = If<true, "a", "b'>;
- * // "b"
- * type F = If<false, "a", "b">;
- * ```
- */
-export type If<C extends boolean, T, F> = C extends T ? C | F : never;

package/src/types/Include.ts

@@ -1,18 +0,0 @@
-/**
- * **Include<T, U, L>**
- * 
- * _Allows_ any value `T` which extends `U` otherwise sets type to `never`. Normally, you'll just ignore
- * the `L` generic but if need the comparison to be literal you can set to `true`: 
- * 
- * ```ts
- * const foo: "foo" = "foo";
- * // "foo"
- * type Normal = Include<typeof foo, string>;
- * // L1 is never, L2 is "foo"
- * type L1 = Include<typeof foo, string, true>;
- * type L2 = Include<typeof foo, "foo", true>;
- * ```
- */
-export type Include<T, U, L extends boolean = false> = L extends true
-  ? T extends U ? U extends T ? T : never : never
-  : T extends U ? T : never;

package/src/types/KeyedRecord.ts

@@ -1,21 +0,0 @@
-/**
- * A "KeyedRecord" is intended to store a value without
- * losing any ability to infer type information later.
- *
- * The structure is always represented as a two-key
- * dictionary, where one key is always `__key` and the value
- * of this key points to the second key.
- *
- * For example:
- * ```ts
- * const song: KeyedRecord = { __key: "song", song: XXX }
- * ```
- */
-export type KeyedRecord<
-  K extends string,
-  V extends any,
-  T extends { __key: K } = { __key: K },
-  U extends keyof T = keyof T & K
-> = {
-  [X in U]: T[X];
-} & { K: V };

package/src/types/Keys.ts

@@ -1,26 +0,0 @@
-/**
- * A Utility class that provides the same functionality as the built-in
- * `keyof` TS operator but can also:
- *
- * - receive an array of strings and convert that into a union type.
- * - you can exclude literal string from the returned result
- *
- * ```ts
- * const t1 = { foo: 1, bar: 2 };
- * // "foo" | "bar"
- * type K = Keys<typeof t1>;
- * const t2 = ["foo", "bar"] as const;
- * // "foo" | "bar"
- * type K = Keys<typeof t2>;
- * ```
- */
-export type Keys<
-  T extends Record<string, any> | readonly string[],
-  W extends string | undefined = undefined
-> = T extends readonly string[]
-  ? W extends string
-    ? Exclude<T[number], W>
-    : T[number]
-  : W extends string
-  ? Exclude<keyof T & string, W>
-  : keyof T & string;

package/src/types/Length.ts

@@ -1,8 +0,0 @@
-/**
- * Utility type which returns the length of an array literal
- * 
- * ```ts
- * type Three = Length<[ "a", "b", "c" ]>;
- * ```
- */
-export type Length<T extends readonly any[]> = T["length"];

package/src/types/Mutable.ts

@@ -1,8 +0,0 @@
-import { IsObject } from "./boolean-logic";
-
-/**
- * Makes a readonly structure mutable
- */
-export type Mutable<T> = {
-  -readonly [K in keyof T]: IsObject<T[K]> extends true ? Mutable<T[K]> : T[K];
-};

package/src/types/Narrowable.ts

@@ -1,5 +0,0 @@
-/**
- * A union of types used in conjunction with the `literalValues()` function
- * to produce a _narrow_ type definition of a passed in dictionary object.
- */
-export type Narrowable = string | number | boolean | symbol | object | undefined | void | null | {};

package/src/types/Not.ts

@@ -1,13 +0,0 @@
-/**
- * Provides a negation of a type of the type `T` _not_ `U`.
- * ```ts
- * const foo = 42;
- * // 33
- * type NotTheMeaningOfLife = Not<33, 42>;
- * // never
- * type NotTheMeaningOfLife = Not<42, 42>;
- * ```
- * 
- * Note: same as `Exclude`
- */
-export type Not<T, U> = T extends U ? never : T;

package/src/types/Numeric.ts

@@ -1,20 +0,0 @@
-type Digital = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
-type MakeArray<S extends string, T extends any[] = []> = S extends `${T["length"]}`
-  ? T
-  : MakeArray<S, [...T, 0]>;
-type Multiply10<T extends any[]> = [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T];
-
-/**
- * Converts a string literal to a numeric literal
- * ```ts
- * // 0
- * type Zero = Numeric<"0">;
- * // 10
- * type Ten = Numeric<"10">;
- * ```
- */
-export type Numeric<S extends string, T extends any[] = []> = S extends `${infer S1}${infer S2}`
-  ? S1 extends Digital
-    ? Numeric<S2, [...Multiply10<T>, ...MakeArray<S1>]>
-    : never
-  : T["length"];

package/src/types/Opaque.ts

@@ -1,11 +0,0 @@
-
-/**
- * **Opaque**
- * 
- * Create an opaque type, which hides its internal details from the public, and 
- * can only be created by being used explicitly.
- * 
- * Note: taken from [type-fest](https://github.com/sindresorhus/type-fest/blob/main/source/opaque.d.ts)
- * repo.
- */
-export type Opaque<Type, Token = unknown> = Type & { readonly __opaque__: Token };

package/src/types/README.md

@@ -1,3 +0,0 @@
-# Types
-
-A directory for types only. These types _will_ be exported as symbols during the build process.

package/src/types/Retain.ts

@@ -1,16 +0,0 @@
-import { Include } from "./Include";
-/**
- * **Retain<T, K>**
- * 
- * Reduces the type system to just the key/values which are represented in `K`.
- * The `L` generic can largely be ignored unless you need _literal_ equality.
- * 
- * ```ts
- * type Obj = { foo: 1, bar: number, baz: string };
- * // { foo: 1, bar: number }
- * type Retained = Retain<Obj, "foo" | "bar">;
- * ```
- * 
- * **Note:** in essence this is the _opposite_ of `Exclude<T,K>`
- */
-export type Retain<T, K extends keyof T> = Pick<T, Include<keyof T, K>>;

package/src/types/SimplifyObject.ts

@@ -1,12 +0,0 @@
-import { ExpandRecursively } from "./ExpandRecursively";
-import { UnionToIntersection } from "./type-conversion/UnionToIntersection";
-
-/**
- * Often when mutating the shape of an object you will end up with the union of a number of
- * `Record<string, x>` and `Record<string, y>` which is messy to look at and take away meaning.
- *
- * This type utility will cleanup an object and return a simple dictionary definition for it.
- */
-export type SimplifyObject<T extends {}> = ExpandRecursively<
-  UnionToIntersection<ExpandRecursively<T>>
->;

package/src/types/Transformer.ts

@@ -1,15 +0,0 @@
-import { SameKeys } from "./dictionary/SameKeys";
-
-/**
- * **Transformer**
- *
- * A function responsible for transforming the _values_ of
- * dictionary `I` into different _values_ for dictionary `O`.
- *
- * This type utility assumes that _keys_ of both dictionaries
- * are the same.
- */
-export type Transformer<I extends object, O extends SameKeys<I>, K extends keyof I = keyof I> = (
-  input: I,
-  key: K
-) => O[K];

package/src/types/TypeGuard.ts

@@ -1,7 +0,0 @@
-/**
- * **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> = (thing: unknown) => thing is T;

package/src/types/Where.ts

@@ -1,40 +0,0 @@
-import { Include } from "./Include";
-/**
- * Allows filtering down `T` to those which extend a given type `U`.
- *
- * - `T` is either a dictionary (where keys will be used to compare) or
- * a readonly sting array.
- * ```ts
- * const arr = ["foo", "bar", "baz"];
- * // "bar" | "baz"
- * type BA = Where<typeof arr, `ba${string}`>;
- * ```
- */
-export type Where<
-  T extends Record<string, any> | readonly string[],
-  U
-> = T extends readonly string[]
-  ? Include<T[number], U>
-  : {
-      [K in keyof T]: K extends U ? K : never;
-    }[keyof T];
-
-/**
- * Allows filtering down `T` to those which extend a given type `U`.
- *
- * - `T` is either a dictionary (where keys will be used to compare) or
- * a readonly sting array.
- * ```ts
- * const arr = ["foo", "bar", "baz"];
- * // "foo"
- * type F = WhereNot<typeof arr, `ba${string}`>;
- * ```
- */
-export type WhereNot<
-  T extends Record<string, any> | readonly string[],
-  U
-> = T extends readonly string[]
-  ? Exclude<T[number], U>
-  : {
-      [K in keyof T]: K extends U ? never : K;
-    }[keyof T];

package/src/types/alphabetic/AllCaps.ts

@@ -1,15 +0,0 @@
-
-/**
- * Indicates whether `T` has _all_ uppercase characters in it.
- * ```ts
- * // true
- * type T = AllCaps<"FOOBAR">;
- * // false 
- * type T = AllCaps<"FooBar">;
- * // "unknown"
- * type T = AllCaps<string>;
- * ```
- */
-export type AllCaps<T extends string> = string extends T
-  ? "unknown"
-  : T extends Uppercase<T> ? true : false;

package/src/types/alphabetic/CamelCase.ts

@@ -1,3 +0,0 @@
-import { PascalCase } from "./PascalCase";
-
-export type CamelCase<S extends string> = string extends S ? string : Uncapitalize<PascalCase<S>>;

package/src/types/alphabetic/CapFirstAlpha.ts

@@ -1,23 +0,0 @@
-import { Replace } from "../string-literals";
-import { NonAlpha } from "./alpha-characters";
-
-/**
- * Strips the non-alpha characters that lead a string
- */
-export type StripLeftNonAlpha<S extends string> = S extends `${infer First}${infer Rest}`
-  ? First extends NonAlpha
-    ? StripLeftNonAlpha<Rest>
-    : S
-  : never;
-
-/**
- * identifies the leading characters which are _not_ alphabetical
- */
-export type LeadingNonAlpha<S extends string> = Replace<S, StripLeftNonAlpha<S>, "">;
-
-/**
- * Capitalize the first alphabetical character in the string
- */
-export type CapFirstAlpha<T extends string> = LeadingNonAlpha<T> extends string
-  ? `${LeadingNonAlpha<T>}${Capitalize<Replace<T, LeadingNonAlpha<T>, "">>}`
-  : Capitalize<T>;

package/src/types/alphabetic/CapitalizeWords.ts

@@ -1,9 +0,0 @@
-/**
- * Capitalize all words in a string
- */
-export type CapitalizeWords<S extends string> =
-  S extends `${infer L} ${infer R}` ? `${CapitalizeWords<L>} ${CapitalizeWords<R>}` :
-  S extends `${infer L},${infer R}` ? `${CapitalizeWords<L>},${CapitalizeWords<R>}` :
-  S extends `${infer L}.${infer R}` ? `${CapitalizeWords<L>}.${CapitalizeWords<R>}` :
-  Capitalize<S>;
-

package/src/types/alphabetic/Cardinality.ts

@@ -1,80 +0,0 @@
-import { UnionToTuple } from "../type-conversion";
-
-export type OneToOne = `1:1`;
-export type OneToMany = `1:M`;
-export type OneToZero = `1:0`;
-export type ZeroToOne = `0:1`;
-export type ZeroToMany = `0:M`;
-export type ZeroToZero = `0:0`;
-export type ManyToMany = "M:M";
-export type ManyToOne = "M:1";
-export type ManyToZero = "M:0";
-
-export type CardinalityNode = "0" | "1" | "M";
-
-/**
- * Cardinality which expects a singular input and requires
- * 1 or many outputs.
- *
- * Note: choose `CardinalityFilter1` if you want to allow output
- * to have no outputs.
- */
-export type Cardinality1 = OneToOne | OneToMany;
-
-/**
- * Cardinality which expects a singular input and maps to 0,
- * 1, or many outputs.
- */
-export type CardinalityFilter1 = OneToOne | OneToMany | OneToZero;
-
-/**
- * Cardinality which expects a singular input which is allowed to be
- * _undefined_ or the expected type.
- */
-export type Cardinality0 = ZeroToOne | ZeroToMany | OneToOne | OneToMany;
-
-/**
- * Cardinality which expects a singular input -- which is allowed to be
- * _undefined_ -- and maps to 0,
- * 1, or many outputs.
- */
-export type CardinalityFilter0 =
-  | ZeroToOne
-  | ZeroToMany
-  | OneToOne
-  | OneToMany
-  | OneToZero
-  | ZeroToZero;
-
-export type CardinalityExplicit = `${number}:${number}`;
-
-/**
- * Cardinality of any sort between two types
- */
-export type Cardinality =
-  | CardinalityFilter0
-  | CardinalityFilter1
-  | ManyToMany
-  | ManyToOne
-  | ManyToZero
-  | CardinalityExplicit;
-
-export type CardinalityTuple<T extends Cardinality> = UnionToTuple<T>;
-
-/**
- * The first or _input_ part of the Cardinality relationship
- */
-export type CardinalityIn<T extends Cardinality> = T extends `${infer IN}:${string}` ? IN : never;
-
-/**
- * The second or _output_ part of the Cardinality relationship
- */
-export type CardinalityOut<T extends Cardinality> = T extends `${string}:${infer OUT}`
-  ? OUT
-  : never;
-
-export type CardinalityInput<T, C extends Cardinality> = CardinalityTuple<C>[0] extends 0
-  ? T | undefined
-  : CardinalityTuple<C>[0] extends 1
-  ? T
-  : T[];

package/src/types/alphabetic/DashToSnake.ts

@@ -1,3 +0,0 @@
-export type DashToSnake<T extends string> = T extends `${infer HEAD}-${infer TAIL}`
-  ? DashToSnake<`${HEAD}_${TAIL}`>
-  : T;

package/src/types/alphabetic/DashUppercase.ts

@@ -1,19 +0,0 @@
-import { HasUppercase } from "./HasUppercase";
-
-type _DU<T extends string> = T extends Lowercase<T> ? T : `-${Lowercase<T>}`;
-
-/**
- * Converts uppercase characters to a dash and then the lowercase equivalent
- * ```ts
- * // "one-two-three"
- * type T = DashUppercase<"oneTwoThree">;
- * ```
- * 
- * _Intended to be used as a lower level utility; prefer `Dasherize<T>` for more full-fledged
- * dash solution_.
- */
-export type DashUppercase<T extends string> = HasUppercase<T> extends false ? T :
-  T extends `${infer C0}${infer C1}${infer R}` ?
-  `${_DU<C0>}${_DU<C1>}${DashUppercase<R>}` :
-  T extends `${infer C0}${infer R}` ? `${_DU<C0>}${DashUppercase<R>}` :
-  "";

package/src/types/alphabetic/Dasherize.ts

@@ -1,23 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
-import { Trim } from "../string-literals";
-import { DashUppercase } from "./DashUppercase";
-import { LowerAllCaps } from "./LowerAllCaps";
-
-/**
- * Converts a string literal into a _dasherized_ format while ignoring _exterior_ whitespace.
- *
- * ```ts
- * // "foo-bar"
- * type Dash = Dasherize<"foo_bar">;
- * type Dash = Dasherize<"fooBar">;
- * type Dash = Dasherize<"FooBar">;
- * // "\n  foo-bar \t"
- * type Dash = Dasherize<"\n  foo bar \t">;
- * ```
- */
-export type Dasherize<S extends string> = string extends S
-  ? string
-  : DashUppercase<Trim<LowerAllCaps<S>>> extends `${infer Begin}${"_" | " "}${infer Rest}`
-  ? Dasherize<`${Lowercase<Begin>}-${Rest}`>
-  : Lowercase<DashUppercase<Uncapitalize<Trim<LowerAllCaps<S>>>>>;

package/src/types/alphabetic/EnsureLeading.ts

@@ -1,24 +0,0 @@
-import { IfLiteral } from "../boolean-logic/IsLiteral";
-
-/**
- * **EnsureLeading**`<T, U>`
- *
- * Will ensure that `T` ends with the _substring_ `U` when
- * both are string literals.
- *
- * ```ts
- * type T = " World";
- * type U = "Hello";
- * // "Hello World"
- * type R = EnsureLeading<T,U>;
- * ```
- */
-export type EnsureLeading<T extends string, U extends string> = IfLiteral<
-  // can only operate on literal strings
-  T,
-  // this path represents successful strip opp
-  // but we must never accept `U` being wide
-  string extends U ? never : T extends `${U}${string}` ? T : `${U}${T}`,
-  // here we must stay wide
-  string
->;

package/src/types/alphabetic/EnsureTrailing.ts

@@ -1,24 +0,0 @@
-import { IfLiteral } from "../boolean-logic/IsLiteral";
-
-/**
- * **EnsureTrailing**`<T, U>`
- *
- * Will ensure that `T` ends with the substring `U` when
- * both are string literals.
- *
- * ```ts
- * type T = "Hello";
- * type U = " World";
- * // "Hello World"
- * type R = EnsureTrailing<T,U>;
- * ```
- */
-export type EnsureTrailing<T extends string, U extends string> = IfLiteral<
-  // can only operate on literal strings
-  T,
-  // this path represents successful strip opp
-  // but we must never accept `U` being wide
-  string extends U ? never : T extends `${string}${U}` ? T : `${T}${U}`,
-  // here we must stay wide
-  string
->;

package/src/types/alphabetic/HasUppercase.ts

@@ -1,16 +0,0 @@
-import { UpperAlpha } from "./alpha-characters";
-
-/**
- * Indicates whether `T` has uppercase characters in it.
- * ```ts
- * // true
- * type T = HasUppercase<"Foobar">;
- * // false 
- * type T = HasUppercase<"foobar">;
- * // "unknown"
- * type T = HasUppercase<string>;
- * ```
- */
-export type HasUppercase<T extends string> = string extends T
-  ? "unknown"
-  : T extends `${string}${UpperAlpha}${string}` ? true : false;

package/src/types/alphabetic/IsCapitalized.ts

@@ -1,18 +0,0 @@
-/**
- * Returns true or false value based on whether the string literal is capitalized.
- * ```ts
- * // true
- * type T2 = IsCapitalized<"One">;
- * // false
- * type T1 = IsCapitalized<"one">;
- * // "unknown"
- * const a: string = "Hi";
- * type T3 = IsCapitalized<typeof a>;
- * ```
- * 
- * Note: _if the value passed in is a "string" then the result will be "unknown"_
- */
-export type IsCapitalized<T extends string> = string extends T
-  ? "unknown"
-  : T extends Capitalize<T> ? true : false;
-