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

Last updated