useful-typescript-types v1.5.2

useful-typescript-types

Types I'm tired of rewriting.

Table of Contents

• Utility Types
  • ObjectPath<T>
    • Example
  • ObjectPathContainsKey<T, Key>
    • Example
  • ValueAtObjectPath
    • Example
  • DeepPartial<T>
  • ArrayItem<T>
  • Tuple<T, N>
    • Example
  • VariadicTuple<T>
    • Example
  • Nullable<T>
  • RequiredProperties<T>
  • OmitFunctionKeys<T>
  • PickKeysByValue
    • PickFunctionKeys<T>
    • PickObjectKeys<T>
    • PickArrayKeys<T>
    • PickStringKeys<T>
    • PickNumberKeys<T>
  • Mutable<T>
  • Immutable<T>
• Syntactic Sugar Types
  • Primitives
  • Json
    • JsonObject
    • JsonArray
    • Json Value
  • Comparables
  • Callback<T>
    • Example
  • CallbackWithArgs<T, Args>
    • Example
  • Result<Success, Error>
    • Example
    • Example
  • Action<Type, Payload>
    • Example

Utility Types

ObjectPath<T>

Get the path keys of an object as string literals.

Example

const myObj = {
  foo: {
    bar: "hi",
    baz: "hello",
  },
};

type MyObjPath = ObjectPath<typeof myObj>; // "foo" | "foo.bar" | "foo.baz"

ObjectPathContainsKey<T, Key>

Get the path keys of an object that contains a certain key.

Example

const myObj = {
  foo: {
    bar: {
      baz: "hi",
    },
  },
};

type findBazPath = ObjectPathContainsKey<typeof myObj, "baz">; // "foo.bar"

ValueAtObjectPath

Get the value of an object at a certain path (using dot notation)

Example

const myObj = {
  foo: {
    bar: {
      baz: "hi",
    },
  },
} as const;

type baz = ValueAtPath<typeof myObj, "foo.bar.baz">; // "hi"

DeepPartial<T>

Make all properties and nested properties of an object optional.

ArrayItem<T>

Get the type of an array item.

Tuple<T, N>

Define a tuple with exactly 2 elements of types T and N.

Example

const tuple: Tuple<string, number> = ["foo", 1];

VariadicTuple<T>

Define a tuple with a variable number of elements.

Example

const vTuple: VariadicTuple<string, number, boolean> = ["foo", 1, true];

Nullable<T>

Define a type that can be null or of type T.

RequiredProperties<T>

Make all properties of an object required, removing optional modifiers.

OmitFunctionKeys<T>

Omit keys of an object that have function values.

PickKeysByValue

Pick keys of an object that have Type values

const obj = { foo: "bar", baz: 42 };

type MyKeys = PickKeysByValue<typeof obj, string>; // "foo"

PickFunctionKeys<T>

Pick keys of an object that have function values.

PickObjectKeys<T>

Pick keys of an object that have object values.

PickArrayKeys<T>

Pick keys of an object that have array values.

PickStringKeys<T>

Pick keys of an object that have string values.

PickNumberKeys<T>

Pick keys of an object that have number values.

Mutable<T>

Remove readonly modifier from all properties of an object

Immutable<T>

Make all properties of an object readonly

Syntactic Sugar Types

Primitives

Primitive types. Builds on top of Comparables.

Json

Json types.

JsonObject

A Json object consists of a JsonObject or JsonArray, which in turn consist of JsonValues.

JsonArray

A Json array consists of JsonValues.

Json Value

A Json value can be a string, number, boolean, null, JsonObject, or JsonArray.

Comparables

Primitive types that can be compared, including number, string, and BigInteger.

Callback<T>

A function that returns type T or void.

Example

const myCallback: Callback<string> = () => "foo";

CallbackWithArgs<T, Args>

A function that returns type T or void and takes arguments of type Args.

Example

const myCallback: CallbackWithArgs<string, [number, string]> = (num, str) =>
  "foo";

Result<Success, Error>

A result type that can be either a success or an error.

Example

const myResult: Result<string, number> = { success: true, value: "foo" };
const myResult: Result<string, number> = { success: false, error: 101 };

Example

const myDict: Dictionary<string> = { foo: "bar" };

Action<Type, Payload>

For state management systems like Redux, representing an action with a type and payload.

Example

type Actions = Action<"INCREMENT", number> | Action<"DECREMENT", number>;