npm i @hazae41/plume

Features

Current features

Usage

Emitters

/** * Events are described as functions that can accept multiple parameters and return something */typeMyEvents={/**   * This will handle a request and return a response   */request:(data:string)=>string,/**   * This will handle a close and return nothing   */close:(reason?:unknown)=>void,/**   * This will handle an error and return nothing   */error:(reason?:unknown)=>void,}

classMyObject{/**   * Composition over inheritance   */readonlyevents=newSuperEventTarget<MyEvents>()/**   * Dispatch an "error" event with a reason   **/asynconError(reason?:unknown){awaitthis.events.emit("error",reason)}/**   * Dispatch a "close" event without a reason   **/asynconClose(){awaitthis.event.emit("close")}/**   * Dispatch a "request" event and return the returned response   */asyncrequest(data:string):string{constresponse=awaitthis.events.emit("request",data)/**     * When a listener has returned something     */if(response.isSome())returnresponse.get()/**     * When no listener has returned     */thrownewError(`Unhandled`)}}

Listeners

constobject=newMyObject()object.on("request",(request:string)=>{if(request==="hello")/**     * Return something and skip next listeners     */returnnewSome("world")/**   * Unhandled by this listener   */returnnewNone()})object.on("request",(request:string)=>{if(request==="it")/**     * Return something and skip next listeners     */returnnewSome("works")/**   * Unhandled by this listener   */returnnewNone()})object.on("request",(request:string)=>{if(request==="have")/**     * Return something and skip next listeners     */returnnewSome("fun")/**   * Unhandled by this listener   */returnnewNone()})

Sequenced dispatching (default)

for(constlisteneroflisteners){constreturned=awaitlistener(...)if(returned.isSome())returnreturnedcontinue}returnnewNone()

/** * This listener will be called first */myObject.events.on("message",async(message:string)=>{awaitdoSometing(message)returnnewSome(1)},{passive:false})/** * This listener will be skipped */myObject.events.on("message",async(message:string)=>{awaitdoSometing2(message)returnnewSome(2)},{passive:false})/** * Some(1) */console.log(awaitmyObject.emit("message","hello world"))

Parallel dispatching

constpromises=newArray<Promise<...>>()for(constlisteneroflisteners)promises.push(listener(...))constreturneds=awaitPromise.all(promises)for(constreturnedofreturneds)if(returned.isSome())returnreturnedreturnnewNone()

/** * This listener will be called first */myObject.events.on("message",async(message:string)=>{awaitdoSometing(message)returnnewSome(1)},{passive:true})/** * This listener will be called too */myObject.events.on("message",async(message:string)=>{awaitdoSometing(e.data)returnnewSome(2)},{passive:true})/** * Some(1) */console.log(awaitmyObject.emit("message","hello world"))

Waiting for an event

import{Future}from"@hazae41/future"asyncfunctionrequestAndWait(id:number,request:string):Promise<string>{constsocket=newMySocket()socket.send({ id,text:request})constresponse=awaitsocket.wait("message",async(future:Future<string>,message)=>{/**     * Only wait for a message with the same id     */if(message.id===id){/**       * Resolve with the text       */future.resolve(message.text)/**       * Do not skip other listeners       */returnnewNone()}/**     * Do not skip other listeners     */returnnewNone()})returnresponse}

Composing waiters with automatic disposal

import{Future}from"@hazae41/future"asyncfunctionrequestAndWaitOrClose(id:number,request:string):Promise<string>{constsocket=newMySocket()socket.send({ id,text:request})/**   * Resolve on message   */  usingevent=socket.wait("message",async(future:Future<string>,message)=>{if(message.id===id){future.resolve(message.text)returnnewNone()}returnnewNone()})/**   * Reject on close   */  usingclose=socket.wait("close",(future:Future<never>)=>{future.reject(newError("Closed"))returnnewNone()})returnawaitPromise.race([event,close])}

import{Future}from"@hazae41/future"asyncfunctionrequestAndWaitOrCloseOrErrorOrSignal(id:number,request:string,signal:AbortSignal):Promise<string>{constsocket=newMySocket()socket.send({ id,text:request})/**   * Resolve on message   */  usingevent=socket.wait("message",async(future:Future<string>,message)=>{if(message.id===id){future.resolve(message.text)returnnewNone()}returnnewNone()})/**   * Reject on signal   */  usingabort=Plume.AbortedError.waitOrThrow(signal)/**   * Reject on error (only if the target has an "error" event)   */  usingerror=Plume.ErroredError.waitOrThrow(socket)/**   * Reject on close (only if the target has a "close" event)   */  usingclose=Plume.ClosedError.waitOrThrow(socket)returnawaitPromise.race([event,close,error,abort])}

import{Future}from"@hazae41/future"asyncfunctionrequestAndWaitOrCloseOrErrorOrSignal(id:number,request:string,signal:AbortSignal):Promise<string>{constsocket=newMySocket()socket.send({ id,text:request})constresponse=awaitPlume.waitOrCloseOrErrorOrSignal(socket,"message",async(future:Future<string>,message)=>{if(message.id===id){future.resolve(message.text)returnnewNone()}returnnewNone()},signal)returnresponse}