EVT
v2
Search…
⌃K
Links

Helper types

ToNonPostableEvt<E>

NonPostableEvt<T> and StatefulReadonlyEvt<T> are interfaces implemented respectively by the classes Evt<T> and StatefulEvt<T>. They contains all the methods but the ones used to post events, namely: .post(), .postOnceHandled() and the .state setter for StatefulReadonlyEvt
import { ToNonPostableEvt } from "evt";
​
ToNonPostableEvt<Evt<T>> → NonPostableEvt<T>
ToNonPostableEvt<SatefulEvt<T>> → StatefulReadonlyEvt<T>
ToNonPostable<VoidEvt> → NonPostable<Void>
ToNonPostable<NonpostableEvt<T>> → NonPostableEvt<T>
​
ToNonPostableEvt<{
evtText: Evt<string>;
evtCount: StatefulEvt<number>;
type: "FOO"
}>
→
{
evtText: NonPostableEvt<string>;
evtCount: StatefulNonpostableEvt<number>;
type: "FOO"
}
Example use of the NonPostableEvt interface:
import { Evt, NonPostableEvt } from "evt";
​
const evtText= new Evt<string>();
​
//Api to expose.
export const api:{ evtText: NonPostableEvt<string>; } = { evtText };
​
//evtText exposed by the api cannot be posted…
api.evtText.post //<=== TS error
api.evtText.postOnceMatched //<===== TS error
​
//…but we can post internally.
evtText.post("good");
​Run the example​

ToPostableEvt<E>

Invert of ToNonPostableEvt
import {
ToPostableEvt,
NonPostableEvt,
StatefulReadonlyEvt
} from "evt";
​
ToPostableEvt<NonPostableEvt<T>> → Evt<T>
ToPostableEvt<StatefulReadonlyEvt<T>> → StatefulEvt<T>
ToPostable<NonPostable<void>> → VoidEvt
ToPostable<Evt<T>> → Evt<T>
​
ToPostableEvt<{
evtText: NonPostableEvt<string>;
evtCount: StatefulReadonlyEvt<number>;
type: "FOO"
}>
→
{
evtText: Evt<string>;
evtCount: StatefulEvt<number>;
type: "FOO"
}

UnpackEvt<E>

Extract the type argument of an Evt
import { UnpackEvt } from "evt";
​
UnpackEvt<Evt<number>> → number
UnpackEvt<StatefulEvt<number>> → number
UnpackEvt<NonpostableEvt<number>> → number
​
UnpackEvt<{
evtText: Evt<string>;
evtCount: StatefulEvt<number>;
type: "FOO"
}>
→
{
evtText: string;
evtCount: number;
type: "FOO"
}

Example:

UnpackEvt is a helper type to infer the type argument of an Evt instance.
import { Evt, UnpackEvt } from "evt";
​
const evtHuman = new Evt<{
name: string;
age: number;
gender: "MALE" | "FEMALE"
}>();
​
​
type Human = UnpackEvt<typeof evtHuman>;
​
const human: Human = {
"name": "bob",
"age": 89,
"gender": "MALE"
};
​
evtHuman.post(human);
​Run the example​

SwapEvtType<E, T>

import { SwapEvtType } from "evt";
​
SwapEvtType<Evt<string>, number> → Evt<number>
SwapEvtType<SatefulEvt<string>, number> → SatefulEvt<number>
SwapEvtType<Evt<number>, void> → VoidEvt
SwapEvtType<StatefulEvt<number>, void> → VoidEvt

FactorizeEvt<E>

import { FactorizeEvt } from "evt";
​
FactorizeEvt<Evt<string> | Evt<number>> → Evt<string | number>
//...Work as well with StatefulEvt, NonPostable ect