Cast the passed event as portable.


Evt.asPostable() will be removed in the next major of Evt.

If you are currently using it, consider refactoring your code so that you don't need it anymore.

See this newer example. ( that replace the older one).

 import { Evt }Β from "evt";
 import type {
+  ToPostableEvt
 } from "evt";

 const evtMsg: NonPostableEvt<string> = new Evt();

+(evtMsg as ToPostable<typeof evtMsg>).post("foo");


Evt.asNonPostable() is the identity function with special type annotation

Use this method only onEvt you instantiated yourself. Not as a hack to trigger events on Evt that have been exposed as non-postable by an API.

To invoke post() on a NonPostableEvt or a StatefullReadonlyEvt.

Without this method this would be the way for a class to expose Evt that are posted internally and exposed to be listened.

import { Evt } from "evt";

class Socket2 {

    private readonly _evtIsConnected= Evt.create(false);
    private readonly _evtMessage= Evt.create<Uint8Array>();

    readonly evtIsConnected= Evt.asNonPostable(this._evtIsConnected);
    readonly evtMessage= Evt.asNonPostable(this._evtMessage);

        OR, more explicit but require to repeat the types and to
        import type { StatefulReadonlyEvt, NonPostableEvt } from "evt";

    readonly evtIsConnected: StatefulReadonlyEvt<boolean>= this._evtIsConnected;
    readonly evtMessage: NonPostableEvt<Uint8Array> = this._evtMessage;


        this._evtIsConnected.state = true;
        this._evtMessage.post(new Uint8Array(111));



Now it can be frustrating to have to store a private property only to call post on a object that we know is postable. Here is were this method come in handy:

class Socket {

    readonly evtIsConnected= Evt.asNonPostable(Evt.create(false));
    readonly evtMessage= Evt.asNonPostable(Evt.create<Uint8Array>());


        Evt.asPostable(this.evtIsConnected).state = true;
        Evt.asPostable(this.evtMessage).post(new Uint8Array(111));



Last updated