Class: Optional<T>

Type parameters

Name
T

Hierarchy

• Optional

  ↳ AbsentOptional

  ↳ PresentOptional

Constructors

constructor

• new Optional<T>()

Type parameters

Name
T

Methods

asJSON

▸ Abstract asJSON(): null | T

Serialize a value using designed's preferred #asJSON method

Returns

null | T

Defined in

packages/optional/src/Optional.ts:304

---

call

▸ call<K>(key, ...args): OptionalOf<ReturnType<T[K] extends (...args: any[]) => any ? any[any] : never>>

Invoke a method on the wrapped object and return an optional of the return value

Type parameters

Name	Type
K	extends string | number | symbol

Parameters

Name	Type
key	K
...args	Parameters<T[K] extends (...args: any[]) => any ? any[any] : never>[]

Returns

OptionalOf<ReturnType<T[K] extends (...args: any[]) => any ? any[any] : never>>

Defined in

packages/optional/src/Optional.ts:194

---

callAsync

▸ callAsync<K>(key, ...args): AsyncOptionalOf<ReturnType<T[K] extends (...args: any[]) => any ? any[any] : never>>

Invoke a method on the wrapped object and return an Async Optional of the return value

Type parameters

Name	Type
K	extends string | number | symbol

Parameters

Name	Type
key	K
...args	Parameters<T[K] extends (...args: any[]) => Promise<any> ? any[any] : never>[]

Returns

AsyncOptionalOf<ReturnType<T[K] extends (...args: any[]) => any ? any[any] : never>>

Defined in

packages/optional/src/Optional.ts:206

---

defaultGet

▸ defaultGet<X>(method): MaybePresentOptionalOf<T> | MaybePresentOptionalOf<X>

Inject a default value to the optional if it is absent to allow continued chaining

Type parameters

Name
X

Parameters

Name	Type
method	() => X

Returns

MaybePresentOptionalOf<T> | MaybePresentOptionalOf<X>

Defined in

packages/optional/src/Optional.ts:229

---

defaultGetAsync

▸ defaultGetAsync<X>(method): AsyncOptionalOf<T | X>

Inject a default value to the optional if it is absent to allow continued

Type parameters

Name
X

Parameters

Name	Type
method	() => Promise<X>

Returns

AsyncOptionalOf<T | X>

Defined in

packages/optional/src/Optional.ts:240

---

defaultGetFlat

▸ defaultGetFlat<X>(method): OptionalOf<T | X>

Type parameters

Name
X

Parameters

Name	Type
method	() => Optional<X>

Returns

OptionalOf<T | X>

Defined in

packages/optional/src/Optional.ts:232

---

defaultGetFlatAsync

▸ defaultGetFlatAsync<X>(method): AsyncOptionalOf<T | X>

Type parameters

Name
X

Parameters

Name	Type
method	() => AsyncOptional<X>

Returns

AsyncOptionalOf<T | X>

Defined in

packages/optional/src/Optional.ts:246

---

defaultTo

▸ defaultTo<X>(value): MaybePresentOptionalOf<T> | MaybePresentOptionalOf<X>

Inject a default value to the optional if it is absent to allow continued chaining

Type parameters

Name
X

Parameters

Name	Type
value	X

Returns

MaybePresentOptionalOf<T> | MaybePresentOptionalOf<X>

Defined in

packages/optional/src/Optional.ts:221

---

filter

▸ Abstract filter<X>(predicate): Optional<X>

Example

Will remove a value that does not satisfy the predicate.

ts
Optional.of(5).filter(n => n > 5) // AbsentOptional<number>
Optional.of(5).filter(n => n === 5) // PresentOptional<number>

Type parameters

Name
X

Parameters

Name	Type
predicate	(value: T) => value is X

Returns

Optional<X>

Defined in

packages/optional/src/Optional.ts:105

▸ Abstract filter(predicate): Optional<T>

Parameters

Name	Type
predicate	(value: T) => boolean

Returns

Optional<T>

Defined in

packages/optional/src/Optional.ts:106

---

filterNot

▸ Abstract filterNot<X>(predicate): Optional<Exclude<T, X>>

Type parameters

Name
X

Parameters

Name	Type
predicate	(value: T) => value is X

Returns

Optional<Exclude<T, X>>

Defined in

packages/optional/src/Optional.ts:108

▸ Abstract filterNot(predicate): Optional<T>

Parameters

Name	Type
predicate	(value: T) => boolean

Returns

Optional<T>

Defined in

packages/optional/src/Optional.ts:111

---

flatMap

▸ Abstract flatMap<X>(transform): Optional<X>

Remark

Apply a transform to the value of the optional and return a new optional of its value. This means you can take a function that returns another function and it will "collapse" the optional

Example

ts
Optional.of('Hello').map(s => s.toUpperCase()) // Optional<"HELLO">
Optional.of(null).map(s => s.toUpperCase())    // AbsentOptional<string>

Type parameters

Name
X

Parameters

Name	Type
transform	(value: T) => Optional<X>

Returns

Optional<X>

Defined in

packages/optional/src/Optional.ts:163

---

flatMapAsync

▸ Abstract flatMapAsync<X>(transform): AsyncOptional<X>

Type parameters

Name
X

Parameters

Name	Type
transform	(value: T) => AsyncOptional<X> | Promise<Optional<X>>

Returns

AsyncOptional<X>

Defined in

packages/optional/src/Optional.ts:164

---

get

▸ Abstract get(): T

Example

ts
Optional.of(5).get() // 5
Optional.of(5).get() // throw TypeError

Returns

T

Defined in

packages/optional/src/Optional.ts:291

---

instanceOf

▸ instanceOf<C>(...klasses): Optional<InstanceType<C[number]>>

Type parameters

Name	Type
C	extends (...args: any[]) => any[]

Parameters

Name	Type
...klasses	C

Returns

Optional<InstanceType<C[number]>>

Defined in

packages/optional/src/Optional.ts:113

---

isAbsent

▸ Abstract isAbsent(): this is AbsentOptional<T>

Example

Used in an if statement, will guarantee the type of the optional as either present or absent

ts
if (maybeUser.isAbsent()) {
 maybeUser; // Instance of AbsentOptional<User>
}

Returns

this is AbsentOptional<T>

Defined in

packages/optional/src/Optional.ts:94

---

isPresent

▸ Abstract isPresent(): this is PresentOptional<T>

Example

Used in an if statement, will guarantee the type of the optional as either present or absent

ts
if (maybeUser.isPresent()) {
 maybeUser; // Instance of PresentOptional<User>
}

Returns

this is PresentOptional<T>

Defined in

packages/optional/src/Optional.ts:82

---

map

▸ Abstract map<X>(transform): OptionalOf<X>

Remark

Apply a transform to the value of the optional and return a new optional of the result. This will not allow the return value to be nullable.

Example

ts
Optional.of('Hello').map(s => s.toUpperCase()) // Optional<"HELLO">
Optional.of(null).map(s => s.toUpperCase())    // AbsentOptional<string>

Type parameters

Name
X

Parameters

Name	Type
transform	(value: T) => X

Returns

OptionalOf<X>

Defined in

packages/optional/src/Optional.ts:133

---

mapAsync

▸ Abstract mapAsync<X>(transform): AsyncOptionalOf<X>

Type parameters

Name
X

Parameters

Name	Type
transform	(value: T) => Promise<X>

Returns

AsyncOptionalOf<X>

Defined in

packages/optional/src/Optional.ts:134

---

orElse

▸ Abstract orElse<X>(other): T | X

Example

ts
Optional.of(5).orElse('not there') // 5 (typeof string | number)
Optional.empty().orElse('not there') // 'not there' (typeof string | number)

Type parameters

Name
X

Parameters

Name	Type
other	X

Returns

T | X

Defined in

packages/optional/src/Optional.ts:260

---

orGet

▸ Abstract orGet<X>(supplier): T | X

Example

Use a getter function to return a new value

ts
Optional.of(5).orGet(() => 'not there') // 5 (typeof string | number)

Type parameters

Name
X

Parameters

Name	Type
supplier	() => X

Returns

T | X

Defined in

packages/optional/src/Optional.ts:270

---

orThrow

▸ Abstract orThrow(errThrower): T

Remark

This must throw an exception when the method is invoked or the optional itself will throw a TypeError.

Example

ts
Optional.of(5).orThrow(() => { throw new Error('I am thrown'); })
Optional.of(5).orThrow(() => new Error('I am thrown'))

Parameters

Name	Type
errThrower	() => Error

Returns

T

Defined in

packages/optional/src/Optional.ts:282

---

pick

▸ pick<K>(key): OptionalOf<T[K]>

Select a field from the wrapped object and return an optional of that field.

Example

ts
Optional.of({name: 'Hello'}).select('name') // Optional<"Hello">

Type parameters

Name	Type
K	extends string | number | symbol

Parameters

Name	Type
key	K

Returns

OptionalOf<T[K]>

Defined in

packages/optional/src/Optional.ts:187

---

tap

▸ tap(view): Optional<T>

Parameters

Name	Type
view	(value: T) => unknown

Returns

Optional<T>

Defined in

packages/optional/src/Optional.ts:136

---

tapAsync

▸ tapAsync(view): AsyncOptional<T>

Parameters

Name	Type
view	(value: T) => Promise<unknown>

Returns

AsyncOptional<T>

Defined in

packages/optional/src/Optional.ts:143

---

toArray

▸ Abstract toArray(): T[]

Returns

T[]

Defined in

packages/optional/src/Optional.ts:299

---

toJSON

▸ Abstract toJSON(): null | T

Remark

Used with other libraries to allow serialization to JSON without coercing to a string

Returns

null | T

Defined in

packages/optional/src/Optional.ts:297

---

unzip

▸ Abstract unzip<V>(this): OptionalizeArray<OptionalValue<V>>

Type parameters

Name	Type
V	extends Optional<[any, any], V>

Parameters

Name	Type
this	V

Returns

OptionalizeArray<OptionalValue<V>>

Defined in

packages/optional/src/Optional.ts:171

---

unzip3

▸ Abstract unzip3<V>(this): OptionalizeArray<OptionalValue<V>>

Type parameters

Name	Type
V	extends Optional<[any, any, any], V>

Parameters

Name	Type
this	V

Returns

OptionalizeArray<OptionalValue<V>>

Defined in

packages/optional/src/Optional.ts:174

---

zip

▸ Abstract zip<X>(...others): Optional<OptionalValuesFromTuple<[Optional<T>, ...X[]]>>

Type parameters

Name	Type
X	extends Optional<any>[]

Parameters

Name	Type
...others	X

Returns

Optional<OptionalValuesFromTuple<[Optional<T>, ...X[]]>>

Defined in

packages/optional/src/Optional.ts:168

---

empty

▸ Static empty<T>(): Optional<T>

Remark

Create an empty optional to model a failure case

Type parameters

Name	Type
T	unknown

Returns

Optional<T>

Defined in

packages/optional/src/Optional.ts:68

---

fromJSON

▸ Static fromJSON<T>(data): Optional<T>

Remark

Used for compatibility with other parts of this library that utilize fromJSON/asJSON/toJSON to manage serialization. This is logically the same as Optional.of

Example

ts
Optional.fromJSON(null)
Optional.fromJSON('Hello')

Type parameters

Name	Type
T	any

Parameters

Name	Type
data	T

Returns

Optional<T>

Defined in

packages/optional/src/Optional.ts:62

---

of

▸ Static of<T>(value): OptionalOf<T>

Example

Create an optional from a nullable value. This will remove the types null or undefined using value != null.

ts
Optional.of('Hello') // Optional<string>
Optional.of<string>(null) // Optional<string>

Type parameters

Name
T

Parameters

Name	Type
value	T | Optional<NonNullable<T>>

Returns

OptionalOf<T>

Defined in

packages/optional/src/Optional.ts:43