Module

x/evt/lib/index.ts>NonPostableEvt

💧EventEmitter's typesafe replacement
Go to Latest
interface NonPostableEvt
import { type NonPostableEvt } from "https://deno.land/x/evt@v2.3.1/lib/index.ts";

Properties

readonly
postCount: number

https://docs.evt.land/api/evt/post

Number of times .post(data) have been called.

Methods

toStateful(ctx?: CtxLike): StatefulEvt<T | undefined>
setMaxHandlers(n: number): this
enableTrace(params: { id: string; formatter?: (data: T) => string; log?: ((message?: any, ...optionalParams: any[]) => void) | false; }): void
getInvocableOp<U>(op: Operator<T, U>): Operator.fλ.Stateless<T, U>

TODO: Update doc, it replace: https://docs.evt.land/api/evt/getstatelessop Maybe this feature is too confusing to be documented...

isHandledByOp<U>(op: Operator<T, U>, data: T): boolean

TODO: DOC !!!

isHandled(data: T): boolean

https://docs.evt.land/api/evt/ishandled

Test if posting a given event data will have an effect.

Return true if: -There is at least one handler matching this event data ( at least one handler's callback function will be invoked if the data is posted. ) -Handlers could be will be detached if the event data is posted.

detach<CtxResult>(ctx: CtxLike<CtxResult>): Handler<T, any, CtxLike<CtxResult>>[]

https://docs.evt.land/api/evt/detach

Detach every handlers of the Evt that are bound to the provided context

detach(): Handler<T, any>[]

https://docs.evt.land/api/evt/detach

(unsafe) Detach every handlers from the Evt

pipe<U>(op: Operator.fλ<T, U>): Evt<U>
pipe<U extends T>(op: (data: T) => data is U): Evt<U>
pipe(op: (data: T) => boolean): Evt<T>
pipe(ctx: CtxLike): Evt<T>
pipe<U>(ctx: CtxLike, op: Operator.fλ<T, U>): Evt<U>
pipe<U extends T>(ctx: CtxLike, op: (data: T) => data is U): Evt<U>
pipe(ctx: CtxLike, op: (data: T) => boolean): Evt<T>
pipe<B, C>(op1: Operator.fλ<T, B>, op2: Operator.fλ<B, C>): Evt<C>
pipe<B, C extends B>(op1: Operator.fλ<T, B>, op2: (data: B) => data is C): Evt<C>
pipe<B>(op1: Operator.fλ<T, B>, op2: (data: B) => boolean): Evt<B>
pipe<B extends T, C>(op1: (data: T) => data is B, op2: Operator.fλ<B, C>): Evt<B>
pipe<B>(op1: (data: T) => boolean, op2: Operator.fλ<T, B>): Evt<B>
pipe<B extends T, C extends B>(op1: (data: T) => data is B, op2: (data: B) => data is C): Evt<C>
pipe<B extends T>(op1: (data: T) => data is B, op2: (data: B) => boolean): Evt<B>
pipe<B extends T>(op1: (data: T) => boolean, op2: (data: T) => data is B): Evt<B>
pipe<T>(op1: (data: T) => boolean, op2: (data: T) => boolean): Evt<T>
pipe<B, C, D>(
op1: Operator.fλ<T, B>,
op2: Operator.fλ<B, C>,
op3: Operator.fλ<C, D>,
): Evt<D>
pipe<B, C, D, E>(
op1: Operator.fλ<T, B>,
op2: Operator.fλ<B, C>,
op3: Operator.fλ<C, D>,
op4: Operator.fλ<D, E>,
): Evt<E>
pipe<B, C, D, E>(
op1: Operator.fλ<T, B>,
op2: Operator.fλ<B, C>,
op3: Operator.fλ<C, D>,
op4: Operator.fλ<D, E>,
): Evt<E>
pipe<B, C, D, E, F>(
op1: Operator.fλ<T, B>,
op2: Operator.fλ<B, C>,
op3: Operator.fλ<C, D>,
op4: Operator.fλ<D, E>,
op5: Operator.fλ<E, F>,
): Evt<F>
pipe<B, C>(op1: Operator<T, B>, op2: Operator<B, C>): Evt<C>
pipe<B, C, D>(
op1: Operator<T, B>,
op2: Operator<B, C>,
op3: Operator<C, D>,
): Evt<D>
pipe<B, C, D, E>(
op1: Operator<T, B>,
op2: Operator<B, C>,
op3: Operator<C, D>,
op4: Operator<D, E>,
): Evt<E>
pipe<B, C, D, E, F>(
op1: Operator<T, B>,
op2: Operator<B, C>,
op3: Operator<C, D>,
op4: Operator<D, E>,
op5: Operator<E, F>,
): Evt<F>
pipe(...ops: [Operator<T, any>, ...Operator<any, any>[]]): Evt<any>
pipe<T>(...ops: [Operator<T, any>, ...Operator<any, any>[]]): Evt<any>
waitFor<U>(
ctx: CtxLike,
timeout?: number,
): Promise<U>
waitFor<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
timeout?: number,
): Promise<Q>

https://docs.evt.land/api/evt/waitfor

op - Type guard

ctx

timeout?

waitFor(
op: (data: T) => boolean,
ctx: CtxLike,
timeout?: number,
): Promise<T>

https://docs.evt.land/api/evt/waitfor

op - Filter

ctx

timeout?

waitFor<U>(op: Operator.fλ.Stateless<T, U>, timeout?: number): Promise<U>
waitFor<Q extends T>(op: (data: T) => data is Q, timeout?: number): Promise<Q>

https://docs.evt.land/api/evt/waitfor

op - Type guard

timeout?

waitFor(op: (data: T) => boolean, timeout?: number): Promise<T>
waitFor(ctx: CtxLike, timeout?: number): Promise<T>
waitFor(timeout?: number): Promise<T>
[[Symbol.asyncIterator]](): AsyncIterator<T>
iter<U, CtxResult>(
ctx: CtxLike<CtxResult>,
timeout?: number,
): AsyncIterableEvt<U, CtxResult>

https://docs.evt.land/api/evt/iter

op - fλ

ctx

timeout?

iter<Q extends T, CtxResult>(
op: (data: T) => data is Q,
ctx: CtxLike<CtxResult>,
timeout?: number,
): AsyncIterableEvt<Q, CtxResult>

https://docs.evt.land/api/evt/iter

op - Type guard

ctx

timeout?

iter<CtxResult>(
op: (data: T) => boolean,
ctx: CtxLike<CtxResult>,
timeout?: number,
): AsyncIterableEvt<T, CtxResult>

https://docs.evt.land/api/evt/iter

op - Filter

ctx

timeout?

iter<U, CtxResult>(op: Operator.fλ.Stateless<T, U>, timeout?: number): AsyncIterableEvt<U>
iter<Q extends T>(op: (data: T) => data is Q, timeout?: number): AsyncIterableEvt<Q>

https://docs.evt.land/api/evt/iter

op - Type guard

timeout?

iter(op: (data: T) => boolean, timeout?: number): AsyncIterableEvt<T>
iter<CtxResult>(ctx: CtxLike, timeout?: number): AsyncIterableEvt<T, CtxResult>
iter(timeout?: number): AsyncIterableEvt<T, void>
$attach<U>(
op: Operator.fλ<T, U>,
ctx: CtxLike,
timeout: number,
callback: (transformedData: U) => void,
): Promise<U>

https://docs.evt.land/api/evt/attach

op - fλ

ctx

timeout

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attach<U>(
op: Operator.fλ<T, U>,
ctx: CtxLike,
callback: (transformedData: U) => void,
): this

https://docs.evt.land/api/evt/attach

op - fλ

ctx

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attach<U>(
op: Operator.fλ<T, U>,
timeout: number,
callback: (transformedData: U) => void,
): Promise<U>

https://docs.evt.land/api/evt/attach

op - fλ

timeout

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attach<U>(op: Operator.fλ<T, U>, callback: (transformedData: U) => void): this

https://docs.evt.land/api/evt/attach

op - fλ

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

attach<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
timeout: number,
callback: (data: Q) => void,
): Promise<Q>

https://docs.evt.land/api/evt/attach

op - Type guard

ctx

timeout

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attach() method )

attach(
op: (data: T) => boolean,
ctx: CtxLike,
timeout: number,
callback: (data: T) => void,
): Promise<T>

https://docs.evt.land/api/evt/attach

op - Filter

ctx

timeout

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attach() method )

attach<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
callback: (data: Q) => void,
): this

https://docs.evt.land/api/evt/attach

op - Type guard

ctx

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attach() method )

attach(
op: (data: T) => boolean,
ctx: CtxLike,
callback: (data: T) => void,
): this

https://docs.evt.land/api/evt/attach

op - Filter

ctx

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attach() method )

attach<Q extends T>(
op: (data: T) => data is Q,
timeout: number,
callback: (data: Q) => void,
): Promise<Q>

https://docs.evt.land/api/evt/attach

op - Type guard

timeout

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attach() method )

attach(
op: (data: T) => boolean,
timeout: number,
callback: (data: T) => void,
): Promise<T>

https://docs.evt.land/api/evt/attach

op - Filter

timeout

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attach() method )

attach(
ctx: CtxLike,
timeout: number,
callback: (data: T) => void,
): Promise<T>
attach<Q extends T>(op: (data: T) => data is Q, callback: (data: Q) => void): this

https://docs.evt.land/api/evt/attach

op - Type guard

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attach() method )

attach(op: (data: T) => boolean, callback: (data: T) => void): this

https://docs.evt.land/api/evt/attach

op - Filter

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attach() method )

attach(ctx: CtxLike, callback: (data: T) => void): this
attach(timeout: number, callback: (data: T) => void): Promise<T>
attach(callback: (data: T) => void): this
$attachOnce<U>(
ctx: CtxLike,
timeout: number,
callback: (transformedData: U) => void,
): Promise<U>

https://docs.evt.land/api/evt/attach

op - fλ

ctx

timeout

callback

NOTE: $attachOnce() with '$' is to use only with fλ operators, if your operator return a boolean use the attachOnce() without the '$' prefix.

$attachOnce<U>(
ctx: CtxLike,
callback: (transformedData: U) => void,
): this

https://docs.evt.land/api/evt/attach

op - fλ

ctx

callback

NOTE: $attachOnce() with '$' is to use only with fλ operators, if your operator return a boolean use the attachOnce() without the '$' prefix.

$attachOnce<U>(
timeout: number,
callback: (transformedData: U) => void,
): Promise<U>

https://docs.evt.land/api/evt/attach

op - fλ

timeout

callback

NOTE: $attachOnce() with '$' is to use only with fλ operators, if your operator return a boolean use the attachOnce() without the '$' prefix.

$attachOnce<U>(op: Operator.fλ.Stateless<T, U>, callback: (transformedData: U) => void): this

https://docs.evt.land/api/evt/attach

op - fλ

callback

NOTE: $attachOnce() with '$' is to use only with fλ operators, if your operator return a boolean use the attachOnce() without the '$' prefix.

attachOnce<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
timeout: number,
callback: (data: Q) => void,
): Promise<Q>

https://docs.evt.land/api/evt/attach

op - Type guard

ctx

timeout

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attachOnce() method )

attachOnce(
op: (data: T) => boolean,
ctx: CtxLike,
timeout: number,
callback: (data: T) => void,
): Promise<T>

https://docs.evt.land/api/evt/attach

op - Filter

ctx

timeout

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attachOnce() method )

attachOnce<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
callback: (data: Q) => void,
): this

https://docs.evt.land/api/evt/attach

op - Type guard

ctx

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attachOnce() method )

attachOnce(
op: (data: T) => boolean,
ctx: CtxLike,
callback: (data: T) => void,
): this

https://docs.evt.land/api/evt/attach

op - Filter

ctx

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attachOnce() method )

attachOnce<Q extends T>(
op: (data: T) => data is Q,
timeout: number,
callback: (data: Q) => void,
): Promise<Q>

https://docs.evt.land/api/evt/attach

op - Type guard

timeout

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attachOnce() method )

attachOnce(
op: (data: T) => boolean,
timeout: number,
callback: (data: T) => void,
): Promise<T>

https://docs.evt.land/api/evt/attach

op - Filter

timeout

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attachOnce() method )

attachOnce(
ctx: CtxLike,
timeout: number,
callback: (data: T) => void,
): Promise<T>
attachOnce<Q extends T>(op: (data: T) => data is Q, callback: (data: Q) => void): this

https://docs.evt.land/api/evt/attach

op - Type guard

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attachOnce() method )

attachOnce(op: (data: T) => boolean, callback: (data: T) => void): this

https://docs.evt.land/api/evt/attach

op - Filter

callback

NOTE: If you whish to use a fλ operator ( an operator that do not return a boolean ) the '$' prefix should be used ( use the $attachOnce() method )

attachOnce(ctx: CtxLike, callback: (data: T) => void): this
attachOnce(timeout: number, callback: (data: T) => void): Promise<T>
attachOnce(callback: (data: T) => void): this
$attachExtract<U>(
op: Operator.fλ<T, U>,
ctx: CtxLike,
timeout: number,
callback: (transformedData: U) => void,
): Promise<U>

https://docs.evt.land/api/evt/attach

op - fλ

ctx

timeout

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attachExtract<U>(
op: Operator.fλ<T, U>,
ctx: CtxLike,
callback: (transformedData: U) => void,
): this

https://docs.evt.land/api/evt/attach

op - fλ

ctx

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attachExtract<U>(
op: Operator.fλ<T, U>,
timeout: number,
callback: (transformedData: U) => void,
): Promise<U>

https://docs.evt.land/api/evt/attach

op - fλ

timeout

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attachExtract<U>(op: Operator.fλ<T, U>, callback: (transformedData: U) => void): this

https://docs.evt.land/api/evt/attach

op - fλ

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

attachExtract<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
timeout: number,
callback: (data: Q) => void,
): Promise<Q>

https://docs.evt.land/api/evt/attach

op - Type guard

ctx

timeout

callback

attachExtract(
op: (data: T) => boolean,
ctx: CtxLike,
timeout: number,
callback: (data: T) => void,
): Promise<T>

https://docs.evt.land/api/evt/attach

op - Filter

ctx

timeout

callback

attachExtract<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
callback: (data: Q) => void,
): this

https://docs.evt.land/api/evt/attach

op - Type guard

ctx

callback

attachExtract(
op: (data: T) => boolean,
ctx: CtxLike,
callback: (data: T) => void,
): this

https://docs.evt.land/api/evt/attach

op - Filter

ctx

callback

attachExtract<Q extends T>(
op: (data: T) => data is Q,
timeout: number,
callback: (data: Q) => void,
): Promise<Q>

https://docs.evt.land/api/evt/attach

op - Type guard

timeout

callback

attachExtract(
op: (data: T) => boolean,
timeout: number,
callback: (data: T) => void,
): Promise<T>

https://docs.evt.land/api/evt/attach

op - Filter

timeout

callback

attachExtract(
ctx: CtxLike,
timeout: number,
callback: (data: T) => void,
): Promise<T>
attachExtract<Q extends T>(op: (data: T) => data is Q, callback: (data: Q) => void): this

https://docs.evt.land/api/evt/attach

op - Type guard

callback

attachExtract(op: (data: T) => boolean, callback: (data: T) => void): this
attachExtract(ctx: CtxLike, callback: (data: T) => void): this
attachExtract(timeout: number, callback: (data: T) => void): Promise<T>
attachExtract(callback: (data: T) => void): this
$attachPrepend<U>(
op: Operator.fλ<T, U>,
ctx: CtxLike,
timeout: number,
callback: (transformedData: U) => void,
): Promise<U>

https://docs.evt.land/api/evt/attach

op - fλ

ctx

timeout

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attachPrepend<U>(
op: Operator.fλ<T, U>,
ctx: CtxLike,
callback: (transformedData: U) => void,
): this

https://docs.evt.land/api/evt/attach

op - fλ

ctx

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attachPrepend<U>(
op: Operator.fλ<T, U>,
timeout: number,
callback: (transformedData: U) => void,
): Promise<U>

https://docs.evt.land/api/evt/attach

op - fλ

timeout

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attachPrepend<U>(op: Operator.fλ<T, U>, callback: (transformedData: U) => void): this

https://docs.evt.land/api/evt/attach

op - fλ

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

attachPrepend<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
timeout: number,
callback: (data: Q) => void,
): Promise<Q>

https://docs.evt.land/api/evt/attach

op - Type guard

ctx

timeout

callback

attachPrepend(
op: (data: T) => boolean,
ctx: CtxLike,
timeout: number,
callback: (data: T) => void,
): Promise<T>

https://docs.evt.land/api/evt/attach

op - Filter

ctx

timeout

callback

attachPrepend<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
callback: (data: Q) => void,
): this

https://docs.evt.land/api/evt/attach

op - Type guard

ctx

callback

attachPrepend(
op: (data: T) => boolean,
ctx: CtxLike,
callback: (data: T) => void,
): this

https://docs.evt.land/api/evt/attach

op - Filter

ctx

callback

attachPrepend<Q extends T>(
op: (data: T) => data is Q,
timeout: number,
callback: (data: Q) => void,
): Promise<Q>

https://docs.evt.land/api/evt/attach

op - Type guard

timeout

callback

attachPrepend(
op: (data: T) => boolean,
timeout: number,
callback: (data: T) => void,
): Promise<T>

https://docs.evt.land/api/evt/attach

op - Filter

timeout

callback

attachPrepend(
ctx: CtxLike,
timeout: number,
callback: (data: T) => void,
): Promise<T>
attachPrepend<Q extends T>(op: (data: T) => data is Q, callback: (data: Q) => void): this

https://docs.evt.land/api/evt/attach

op - Type guard

callback

attachPrepend(op: (data: T) => boolean, callback: (data: T) => void): this
attachPrepend(ctx: CtxLike, callback: (data: T) => void): this
attachPrepend(timeout: number, callback: (data: T) => void): Promise<T>
attachPrepend(callback: (data: T) => void): this
$attachOncePrepend<U>(
ctx: CtxLike,
timeout: number,
callback: (transformedData: U) => void,
): Promise<U>

https://docs.evt.land/api/evt/attach

op - fλ

ctx

timeout

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attachOncePrepend<U>(
ctx: CtxLike,
callback: (transformedData: U) => void,
): this

https://docs.evt.land/api/evt/attach

op - fλ

ctx

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attachOncePrepend<U>(
timeout: number,
callback: (transformedData: U) => void,
): Promise<U>

https://docs.evt.land/api/evt/attach

op - fλ

timeout

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attachOncePrepend<U>(op: Operator.fλ.Stateless<T, U>, callback: (transformedData: U) => void): this

https://docs.evt.land/api/evt/attach

op - fλ

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

attachOncePrepend<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
timeout: number,
callback: (data: Q) => void,
): Promise<Q>

https://docs.evt.land/api/evt/attach

op - Type guard

ctx

timeout

callback

attachOncePrepend(
op: (data: T) => boolean,
ctx: CtxLike,
timeout: number,
callback: (data: T) => void,
): Promise<T>

https://docs.evt.land/api/evt/attach

op - Filter

ctx

timeout

callback

attachOncePrepend<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
callback: (data: Q) => void,
): this

https://docs.evt.land/api/evt/attach

op - Type guard

ctx

callback

attachOncePrepend(
op: (data: T) => boolean,
ctx: CtxLike,
callback: (data: T) => void,
): this

https://docs.evt.land/api/evt/attach

op - Filter

ctx

callback

attachOncePrepend<Q extends T>(
op: (data: T) => data is Q,
timeout: number,
callback: (data: Q) => void,
): Promise<Q>

https://docs.evt.land/api/evt/attach

op - Type guard

timeout

callback

attachOncePrepend(
op: (data: T) => boolean,
timeout: number,
callback: (data: T) => void,
): Promise<T>

https://docs.evt.land/api/evt/attach

op - Filter

timeout

callback

attachOncePrepend(
ctx: CtxLike,
timeout: number,
callback: (data: T) => void,
): Promise<T>
attachOncePrepend<Q extends T>(op: (data: T) => data is Q, callback: (data: Q) => void): this

https://docs.evt.land/api/evt/attach

op - Type guard

callback

attachOncePrepend(op: (data: T) => boolean, callback: (data: T) => void): this
attachOncePrepend(ctx: CtxLike, callback: (data: T) => void): this
attachOncePrepend(timeout: number, callback: (data: T) => void): Promise<T>
attachOncePrepend(callback: (data: T) => void): this
$attachOnceExtract<U>(
ctx: CtxLike,
timeout: number,
callback: (transformedData: U) => void,
): Promise<U>

https://docs.evt.land/api/evt/attach

op - fλ

ctx

timeout

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attachOnceExtract<U>(
ctx: CtxLike,
callback: (transformedData: U) => void,
): this

https://docs.evt.land/api/evt/attach

op - fλ

ctx

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attachOnceExtract<U>(
timeout: number,
callback: (transformedData: U) => void,
): Promise<U>

https://docs.evt.land/api/evt/attach

op - fλ

timeout

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

$attachOnceExtract<U>(op: Operator.fλ.Stateless<T, U>, callback: (transformedData: U) => void): this

https://docs.evt.land/api/evt/attach

op - fλ

callback

NOTE: $attach() with '$' is to use only with fλ operators, if your operator return a boolean use the attach() without the '$' prefix.

attachOnceExtract<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
timeout: number,
callback: (data: Q) => void,
): Promise<Q>

https://docs.evt.land/api/evt/attach

op - Type guard

ctx

timeout

callback

attachOnceExtract(
op: (data: T) => boolean,
ctx: CtxLike,
timeout: number,
callback: (data: T) => void,
): Promise<T>

https://docs.evt.land/api/evt/attach

op - Filter

ctx

timeout

callback

attachOnceExtract<Q extends T>(
op: (data: T) => data is Q,
ctx: CtxLike,
callback: (data: Q) => void,
): this

https://docs.evt.land/api/evt/attach

op - Type guard

ctx

callback

attachOnceExtract(
op: (data: T) => boolean,
ctx: CtxLike,
callback: (data: T) => void,
): this

https://docs.evt.land/api/evt/attach

op - Filter

ctx

callback

attachOnceExtract<Q extends T>(
op: (data: T) => data is Q,
timeout: number,
callback: (data: Q) => void,
): Promise<Q>

https://docs.evt.land/api/evt/attach

op - Type guard

timeout

callback

attachOnceExtract(
op: (data: T) => boolean,
timeout: number,
callback: (data: T) => void,
): Promise<T>

https://docs.evt.land/api/evt/attach

op - Filter

timeout

callback

attachOnceExtract(
ctx: CtxLike,
timeout: number,
callback: (data: T) => void,
): Promise<T>
attachOnceExtract<Q extends T>(op: (data: T) => data is Q, callback: (data: Q) => void): this

https://docs.evt.land/api/evt/attach

op - Type guard

callback

attachOnceExtract(op: (data: T) => boolean, callback: (data: T) => void): this
attachOnceExtract(ctx: CtxLike, callback: (data: T) => void): this
attachOnceExtract(timeout: number, callback: (data: T) => void): Promise<T>
attachOnceExtract(callback: (data: T) => void): this