Types

This package contains some lightweight types and interfaces that I commonly use across most of my projects.

``
npm install @baileyherbert/types
`

---

- Action
- Constructor
- Delegate
- Fallback
- Json
- JsonArray
- JsonMap
- Key
- Promisable
- Pull
- Type
- Value

---

$3

Represents a function that has no arguments and returns type T (defaults to unknown).

`ts
let fn: Action = function() {
return true;
}
`

$3

Returns a type that represents the constructor for class T. The class cannot be abstract.

`ts
class Foo {}
const constructor: Constructor = Foo;
`

$3

Represents a function that accepts any arguments and returns type T (defaults to unknown). This is most useful in
an environment with dependency injection.

`ts
let fn: Delegate = function(...args: any[]) {
return true;
}
`

$3

Returns T if it's defined or F otherwise.

`ts
Fallback; // boolean
Fallback; // number
`

$3

Represents data that can be serialized into or deserialized from a JSON string.

`ts
let age: Json = 32;
let name: Json = 'John Doe';
let skills: Json = [
'Programming',
'Engineering',
'Architecture'
];
`

$3

Represents an array that can be serialized into or deserialized from a JSON string.

`ts
let arr: JsonArray = [
'Text',
123456,
{
value: true
}
]
`

$3

Represents an object that can be serialized into or deserialized from a JSON string.

`ts
let profile: JsonMap = {
name: 'John Doe',
age: 32,
skills: [
'Programming',
'Engineering',
'Architecture'
]
}
`

$3

Extracts and returns the key names of object T. When T is undefined, a generic string type will be returned
instead, allowing any key name to be specified.

This can be used to implement type safety and autocompletion with consumer interfaces, while allowing any input when an
interface is not specified.

`ts
type Map = {
first: boolean;
second: string;
};

type Keys = Key`

$3

Returns type T optionally joined with Promise.

`ts
Promisable; // void | Promise
`

$3

Extracts the value of key K from object T _if the value is defined_.

This is identical to Value except it also checks that the value of T[K] is set and allows you to fall back
to another value if not.

`ts
type Map = {
first: boolean;
second: undefined;
};

type A = Value; // boolean
type B = Value; // unknown
`

$3

Returns a type that represents the class T. The class does not have to contain a constructor (i.e. it can be
abstract).

`ts
class Foo {}
const type: Type = Foo;
`

$3

Extracts the value of key K from the given object T. The key must be derived from Key.

When T is undefined, the optional type F will be returned instead. This can be used to accept any input when an
interface is not available.

`ts
type Map = {
value: boolean;
};

type A = Value; // boolean
type B = Value; // unknown
``