A collection of useful types for my TypeScript projects.
npm install @baileyherbert/typesThis 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
---
Represents a function that has no arguments and returns type T (defaults to unknown).
`ts`
let fn: Action
return true;
}
Returns a type that represents the constructor for class T. The class cannot be abstract.
`ts`
class Foo {}
const constructor: Constructor
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
return true;
}
Returns T if it's defined or F otherwise.
`ts`
Fallback
Fallback
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'
];
Represents an array that can be serialized into or deserialized from a JSON string.
`ts`
let arr: JsonArray = [
'Text',
123456,
{
value: true
}
]
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'
]
}
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
Returns type T optionally joined with Promise.
`ts`
Promisable
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
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
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
type B = Value
``