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
StatefulEvt<T>
Handler<T, U> (type)
Last modified 8mo ago