evnty/build/event.cjs

Async-first, reactive event handling library for complex event flows in browser and Node.js

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: Object.getOwnPropertyDescriptor(all, name).get
    });
}
_export(exports, {
    get Event () {
        return Event;
    },
    get EventIterator () {
        return EventIterator;
    },
    get createEvent () {
        return createEvent;
    },
    get createInterval () {
        return createInterval;
    },
    get default () {
        return _default;
    },
    get merge () {
        return merge;
    }
});
const _asynccjs = require("./async.cjs");
const _signalcjs = require("./signal.cjs");
const _listenerregistrycjs = require("./listener-registry.cjs");
const _dispatchresultcjs = require("./dispatch-result.cjs");
class EventIterator {
    #signal;
    constructor(signal){
        this.#signal = signal;
    }
    async next() {
        try {
            const value = await this.#signal.receive();
            return {
                value,
                done: false
            };
        } catch  {
            return {
                value: undefined,
                done: true
            };
        }
    }
    async return() {
        return {
            value: undefined,
            done: true
        };
    }
}
class Event {
    #listeners = new _listenerregistrycjs.ListenerRegistry();
    #signal = new _signalcjs.Signal();
    #disposer;
    #onDispose;
    #sink;
    [Symbol.toStringTag] = 'Event';
    constructor(onDispose){
        this.#onDispose = onDispose;
        this.#disposer = new _asynccjs.Disposer(this);
    }
    get sink() {
        return this.#sink ??= this.emit.bind(this);
    }
    handleEvent(event) {
        this.emit(event);
    }
    get size() {
        return this.#listeners.size;
    }
    emit(value) {
        this.#signal.emit(value);
        return new _dispatchresultcjs.DispatchResult(this.#listeners.dispatch(value));
    }
    lacks(listener) {
        return !this.#listeners.has(listener);
    }
    has(listener) {
        return this.#listeners.has(listener);
    }
    off(listener) {
        this.#listeners.off(listener);
        return this;
    }
    on(listener) {
        this.#listeners.on(listener);
        return ()=>void this.off(listener);
    }
    once(listener) {
        this.#listeners.once(listener);
        return ()=>void this.off(listener);
    }
    clear() {
        this.#listeners.clear();
        return this;
    }
    receive() {
        return this.#signal.receive();
    }
    then(onfulfilled, onrejected) {
        return this.receive().then(onfulfilled, onrejected);
    }
    catch(onrejected) {
        return this.receive().catch(onrejected);
    }
    finally(onfinally) {
        return this.receive().finally(onfinally);
    }
    settle() {
        return this.receive().then((value)=>({
                status: 'fulfilled',
                value
            }), (reason)=>({
                status: 'rejected',
                reason
            }));
    }
    [Symbol.asyncIterator]() {
        return new EventIterator(this.#signal);
    }
    dispose() {
        this[Symbol.dispose]();
    }
    [Symbol.dispose]() {
        if (this.#disposer[Symbol.dispose]()) {
            this.#signal[Symbol.dispose]();
            this.#listeners.clear();
            void this.#onDispose?.();
        }
    }
}
const merge = (...events)=>{
    const mergedEvent = new Event(()=>{
        for (const event of events){
            event.off(mergedEvent.sink);
        }
    });
    for (const event of events){
        event.on(mergedEvent.sink);
    }
    return mergedEvent;
};
const createInterval = (interval)=>{
    let counter = 0;
    const intervalEvent = new Event(()=>clearInterval(timerId));
    const timerId = setInterval(()=>{
        intervalEvent.emit(counter++);
    }, interval);
    return intervalEvent;
};
const createEvent = ()=>new Event();
const _default = createEvent;

//# sourceMappingURL=event.cjs.map