@kuindji/reactive 1.0.21 → 1.0.24

package/README.md

@@ -117,29 +117,28 @@ type ApplicationData = {
         type: string;
         message: string;
     }[];
-}
-const event = createEvent(<() => Partial<ApplicationData>>);
+};
+const event = createEvent<() => Partial<ApplicationData>>();
 event.addListener(() => {
     return {
         user: {
             username: "john",
             role: "admin",
-            loggedIn: true
-        }
-    }
+            loggedIn: true,
+        },
+    };
 });
 event.addListener(() => {
     return {
         notifications: [
             {
                 type: "chat",
-                message: "You've got a new message!"
-            }
-        ]
-    }
+                message: "You've got a new message!",
+            },
+        ],
+    };
 });
 
-
 const applicationData = event.merge();
 ```
 

package/dist/action.d.ts

@@ -1,5 +1,5 @@
 import type { ApiType, BaseHandler, ErrorListenerSignature, ErrorResponse } from "./lib/types";
-export type ActionResponse<Response extends any = any, Args extends any[] = any[]> = {
+export type ActionResponse<Response = any, Args extends unknown[] = unknown[]> = {
     response: Response;
     error: null;
     args: Args;

package/dist/action.js

@@ -1,4 +1,3 @@
-"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,13 +7,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAction = createAction;
-const event_1 = require("./event");
-function createAction(action) {
-    const { trigger, addListener, removeAllListeners, removeListener, promise, } = (0, event_1.createEvent)();
-    const { all: triggerBeforeAction, addListener: addBeforeActionListener, removeAllListeners: removeAllBeforeActionListeners, removeListener: removeBeforeActionListener, promise: beforeActionPromise, } = (0, event_1.createEvent)();
-    const { trigger: triggerError, addListener: addErrorListener, removeAllListeners: removeAllErrorListeners, removeListener: removeErrorListener, promise: errorPromise, hasListener: hasErrorListeners, } = (0, event_1.createEvent)();
+import { createEvent } from "./event";
+export function createAction(action) {
+    const { trigger, addListener, removeAllListeners, removeListener, promise, } = createEvent();
+    const { all: triggerBeforeAction, addListener: addBeforeActionListener, removeAllListeners: removeAllBeforeActionListeners, removeListener: removeBeforeActionListener, promise: beforeActionPromise, } = createEvent();
+    const { trigger: triggerError, addListener: addErrorListener, removeAllListeners: removeAllErrorListeners, removeListener: removeErrorListener, promise: errorPromise, hasListener: hasErrorListeners, } = createEvent();
     const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
         try {
             const beforeResults = triggerBeforeAction(...args);

package/dist/actionBus.js

@@ -1,19 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createActionBus = createActionBus;
-const action_1 = require("./action");
-const event_1 = require("./event");
-function createActionBus(initialActions = {}, errorListener) {
+import { createAction } from "./action";
+import { createEvent } from "./event";
+export function createActionBus(initialActions = {}, errorListener) {
     const actions = new Map();
-    const errorEvent = (0, event_1.createEvent)();
+    const errorEvent = createEvent();
     if (errorListener) {
-        errorEvent.addListener(({ error, args }) => {
-            errorEvent.emit({ error, args, type: "action" });
-        });
+        errorEvent.addListener(errorListener);
     }
     const add = (name, action) => {
         if (!actions.has(name)) {
-            const a = (0, action_1.createAction)(action);
+            const a = createAction(action);
             a.addErrorListener(({ error, args }) => {
                 errorEvent.emit({ name, error, args, type: "action" });
             });
@@ -28,6 +23,9 @@ function createActionBus(initialActions = {}, errorListener) {
     };
     const invoke = (name, ...args) => {
         const action = get(name);
+        if (!action) {
+            throw new Error(`Action ${name} not found`);
+        }
         return action.invoke(...args);
     };
     const on = (name, handler, options) => {

package/dist/actionMap.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createActionMap = createActionMap;
-const action_1 = require("./action");
-function createActionMap(actions, onAnyError) {
+import { createAction } from "./action";
+export function createActionMap(actions, onAnyError) {
     const errorListenersMap = {};
     for (const key in actions) {
         errorListenersMap[key] = (errorResponse) => {
@@ -18,7 +15,7 @@ function createActionMap(actions, onAnyError) {
     }
     const map = {};
     for (const key in actions) {
-        const action = (0, action_1.createAction)(actions[key]);
+        const action = createAction(actions[key]);
         action.addErrorListener(errorListenersMap[key]);
         map[key] = action;
     }

package/dist/event.d.ts

@@ -118,7 +118,7 @@ export declare function createEvent<ListenerSignature extends BaseHandler>(event
     readonly reset: () => void;
     readonly isSuspended: () => boolean;
     readonly isQueued: () => boolean;
-    readonly withTags: <T extends (...args: any[]) => any>(tags: string[], callback: T) => ReturnType<T>;
+    readonly withTags: <R>(tags: string[], callback: () => R) => R;
     readonly promise: (options?: ListenerOptions) => Promise<Parameters<ListenerSignature>>;
     readonly first: (...args: Parameters<ListenerSignature>) => ReturnType<ListenerSignature> | undefined;
     readonly resolveFirst: (...args: Parameters<ListenerSignature>) => Promise<Awaited<ReturnType<ListenerSignature>> | undefined>;

package/dist/event.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEvent = createEvent;
-const asyncCall_1 = require("./lib/asyncCall");
-const listenerSorter_1 = require("./lib/listenerSorter");
-const tagsIntersect_1 = require("./lib/tagsIntersect");
-const types_1 = require("./lib/types");
-function createEvent(eventOptions = {}) {
+import asyncCall from "./lib/asyncCall";
+import listenerSorter from "./lib/listenerSorter";
+import tagsIntersect from "./lib/tagsIntersect";
+import { TriggerReturnType } from "./lib/types";
+export function createEvent(eventOptions = {}) {
     let listeners = [];
-    let errorListeners = [];
+    const errorListeners = [];
     let queue = [];
     let suspended = false;
     let queued = false;
@@ -41,7 +38,7 @@ function createEvent(eventOptions = {}) {
             listeners.forEach((l, inx) => {
                 l.index = inx;
             });
-            listeners.sort((l1, l2) => (0, listenerSorter_1.default)(l1, l2));
+            listeners.sort((l1, l2) => listenerSorter(l1, l2));
         }
         if ((listenerOptions === null || listenerOptions === void 0 ? void 0 : listenerOptions.alwaysFirst) === true
             || (listenerOptions === null || listenerOptions === void 0 ? void 0 : listenerOptions.alwaysLast) === true) {
@@ -116,7 +113,7 @@ function createEvent(eventOptions = {}) {
         }
     };
     const addErrorListener = (handler, context) => {
-        if (listeners.find((l) => l.handler === handler && l.context === context)) {
+        if (errorListeners.find((l) => l.handler === handler && l.context === context)) {
             return;
         }
         errorListeners.push({ handler, context });
@@ -152,10 +149,14 @@ function createEvent(eventOptions = {}) {
     const isQueued = () => queued;
     const reset = () => {
         listeners.length = 0;
+        errorListeners.length = 0;
         queue.length = 0;
         suspended = false;
         queued = false;
         triggered = 0;
+        lastTrigger = null;
+        sortListeners = false;
+        cachedPromise = null;
     };
     const _listenerCall = (listener, args, resolve = null) => {
         let isAsync = listener.async;
@@ -170,11 +171,24 @@ function createEvent(eventOptions = {}) {
         }
         try {
             const result = isAsync !== false
-                ? (0, asyncCall_1.default)(listener.handler, listener.context, args, isAsync)
+                ? asyncCall(listener.handler, listener.context, args, isAsync)
                 : listener.handler.bind(listener.context)(...args);
             if (resolve !== null) {
                 if (result instanceof Promise) {
-                    result.then(resolve);
+                    void result.then(resolve).catch((error) => {
+                        for (const errorListener of errorListeners) {
+                            errorListener.handler({
+                                error: error instanceof Error
+                                    ? error
+                                    : new Error(error),
+                                args: args,
+                                type: "event",
+                            });
+                        }
+                        if (errorListeners.length === 0) {
+                            throw error;
+                        }
+                    });
                 }
                 else {
                     resolve(result);
@@ -199,22 +213,22 @@ function createEvent(eventOptions = {}) {
         }
     };
     const _listenerCallWPrev = (listener, args, prevValue, returnType) => {
-        if (returnType === types_1.TriggerReturnType.PIPE) {
+        if (returnType === TriggerReturnType.PIPE) {
             args[0] = prevValue;
             // since we don't user listener's arg transformer,
             // we don't need to prepare args
             // args = _prepareListenerArgs(args);
             return _listenerCall(listener, args);
         }
-        else if (returnType === types_1.TriggerReturnType.UNTIL_TRUE
+        else if (returnType === TriggerReturnType.UNTIL_TRUE
             && prevValue === true) {
             return true;
         }
-        else if (returnType === types_1.TriggerReturnType.UNTIL_FALSE
+        else if (returnType === TriggerReturnType.UNTIL_FALSE
             && prevValue === false) {
             return false;
         }
-        else if (returnType === types_1.TriggerReturnType.FIRST_NON_EMPTY
+        else if (returnType === TriggerReturnType.FIRST_NON_EMPTY
             && prevValue !== null
             && prevValue !== undefined) {
             return prevValue;
@@ -239,24 +253,24 @@ function createEvent(eventOptions = {}) {
         // in pipe mode if there is no listeners,
         // we just return piped value
         if (listeners.length === 0) {
-            if (returnType === types_1.TriggerReturnType.PIPE) {
+            if (returnType === TriggerReturnType.PIPE) {
                 return args.length > 0 ? args[0] : undefined;
             }
-            else if (returnType === types_1.TriggerReturnType.ALL
-                || returnType === types_1.TriggerReturnType.CONCAT
-                || returnType === types_1.TriggerReturnType.RAW) {
+            else if (returnType === TriggerReturnType.ALL
+                || returnType === TriggerReturnType.CONCAT
+                || returnType === TriggerReturnType.RAW) {
                 return [];
             }
-            else if (returnType === types_1.TriggerReturnType.MERGE) {
+            else if (returnType === TriggerReturnType.MERGE) {
                 return {};
             }
             return;
         }
         const listenersQueue = listeners.slice();
-        const isConsequent = returnType === types_1.TriggerReturnType.PIPE
-            || returnType === types_1.TriggerReturnType.UNTIL_TRUE
-            || returnType === types_1.TriggerReturnType.UNTIL_FALSE
-            || returnType === types_1.TriggerReturnType.FIRST_NON_EMPTY;
+        const isConsequent = returnType === TriggerReturnType.PIPE
+            || returnType === TriggerReturnType.UNTIL_TRUE
+            || returnType === TriggerReturnType.UNTIL_FALSE
+            || returnType === TriggerReturnType.FIRST_NON_EMPTY;
         let listener;
         let listenerResult;
         const results = [];
@@ -272,12 +286,12 @@ function createEvent(eventOptions = {}) {
             }
             if (tags
                 && tags.length > 0
-                && (!listener.tags || !(0, tagsIntersect_1.default)(tags, listener.tags))) {
+                && (!listener.tags || !tagsIntersect(tags, listener.tags))) {
                 continue;
             }
             if (currentTagsFilter !== null
                 && currentTagsFilter.length > 0
-                && !(0, tagsIntersect_1.default)(currentTagsFilter, listener.tags)) {
+                && !tagsIntersect(currentTagsFilter, listener.tags)) {
                 continue;
             }
             listener.count++;
@@ -287,7 +301,7 @@ function createEvent(eventOptions = {}) {
                 continue;
             }
             if (isConsequent && results.length > 0) {
-                let prev = results[results.length - 1];
+                const prev = results[results.length - 1];
                 if (hasPromises) {
                     const prevPromise = prev instanceof Promise
                         ? prev
@@ -309,24 +323,24 @@ function createEvent(eventOptions = {}) {
             if (listener.called === listener.limit) {
                 removeListener(listener.handler, listener.context);
             }
-            if (returnType === types_1.TriggerReturnType.FIRST) {
+            if (returnType === TriggerReturnType.FIRST) {
                 return listenerResult;
             }
             if (isConsequent) {
                 switch (returnType) {
-                    case types_1.TriggerReturnType.UNTIL_TRUE: {
+                    case TriggerReturnType.UNTIL_TRUE: {
                         if (listenerResult === true) {
                             return true;
                         }
                         break;
                     }
-                    case types_1.TriggerReturnType.UNTIL_FALSE: {
+                    case TriggerReturnType.UNTIL_FALSE: {
                         if (listenerResult === false) {
                             return false;
                         }
                         break;
                     }
-                    case types_1.TriggerReturnType.FIRST_NON_EMPTY: {
+                    case TriggerReturnType.FIRST_NON_EMPTY: {
                         if (!hasPromises
                             && !(listenerResult instanceof Promise)
                             && listenerResult !== null
@@ -343,7 +357,7 @@ function createEvent(eventOptions = {}) {
             results.push(listenerResult);
         }
         switch (returnType) {
-            case types_1.TriggerReturnType.RAW: {
+            case TriggerReturnType.RAW: {
                 return results;
             }
             case undefined:
@@ -353,34 +367,36 @@ function createEvent(eventOptions = {}) {
                 }
                 return;
             }
-            case types_1.TriggerReturnType.ALL: {
+            case TriggerReturnType.ALL: {
                 return hasPromises
                     ? Promise.all(results)
                     : results;
             }
-            case types_1.TriggerReturnType.CONCAT: {
+            case TriggerReturnType.CONCAT: {
                 return hasPromises
-                    ? Promise.all(results).then((results) => results.flat())
+                    ? Promise.all(results).then((r) => r.flat())
                     : results.flat();
             }
-            case types_1.TriggerReturnType.MERGE: {
+            case TriggerReturnType.MERGE: {
                 return hasPromises
-                    ? Promise.all(results).then((results) => Object.assign.apply(null, [{}, ...results]))
-                    : Object.assign.apply(null, [{}, ...results]);
+                    ? Promise.all(results).then((r) => Object.assign({}, ...r))
+                    : Object.assign({}, ...results);
             }
-            case types_1.TriggerReturnType.LAST: {
+            case TriggerReturnType.LAST: {
                 return results.pop();
             }
-            case types_1.TriggerReturnType.UNTIL_TRUE: {
+            case TriggerReturnType.UNTIL_TRUE: {
                 return;
             }
-            case types_1.TriggerReturnType.UNTIL_FALSE: {
+            case TriggerReturnType.UNTIL_FALSE: {
                 return;
             }
-            case types_1.TriggerReturnType.FIRST_NON_EMPTY: {
-                return Promise.all(results).then((results) => results.find((r) => r !== undefined && r !== null));
+            case TriggerReturnType.FIRST_NON_EMPTY: {
+                return hasPromises
+                    ? Promise.all(results).then((r) => r.find((item) => item !== undefined && item !== null))
+                    : results.find((item) => item !== undefined && item !== null);
             }
-            case types_1.TriggerReturnType.PIPE: {
+            case TriggerReturnType.PIPE: {
                 return results[results.length - 1];
             }
         }
@@ -390,95 +406,103 @@ function createEvent(eventOptions = {}) {
     };
     const withTags = (tags, callback) => {
         currentTagsFilter = tags;
-        const result = callback();
-        currentTagsFilter = null;
-        return result;
+        try {
+            return callback();
+        }
+        finally {
+            currentTagsFilter = null;
+        }
     };
+    let cachedPromise = null;
     const promise = (options) => {
-        return new Promise((resolve) => {
-            options = Object.assign(Object.assign({}, (options || {})), { limit: 1 });
-            const l = ((...args) => resolve(args));
-            addListener(l, options);
-        });
+        return cachedPromise = cachedPromise
+            || new Promise((resolve) => {
+                options = Object.assign(Object.assign({}, (options || {})), { limit: 1 });
+                const l = ((...args) => {
+                    resolve(args);
+                    cachedPromise = null;
+                });
+                addListener(l, options);
+            });
     };
     const first = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.FIRST);
+        return _trigger(args, TriggerReturnType.FIRST);
     };
     const resolveFirst = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.FIRST);
+        const response = _trigger(args, TriggerReturnType.FIRST);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const all = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.ALL);
+        return _trigger(args, TriggerReturnType.ALL);
     };
     const resolveAll = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.ALL);
+        const response = _trigger(args, TriggerReturnType.ALL);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const last = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.LAST);
+        return _trigger(args, TriggerReturnType.LAST);
     };
     const resolveLast = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.LAST);
+        const response = _trigger(args, TriggerReturnType.LAST);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const merge = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.MERGE);
+        return _trigger(args, TriggerReturnType.MERGE);
     };
     const resolveMerge = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.MERGE);
+        const response = _trigger(args, TriggerReturnType.MERGE);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const concat = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.CONCAT);
+        return _trigger(args, TriggerReturnType.CONCAT);
     };
     const resolveConcat = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.CONCAT);
+        const response = _trigger(args, TriggerReturnType.CONCAT);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const firstNonEmpty = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.FIRST_NON_EMPTY);
+        return _trigger(args, TriggerReturnType.FIRST_NON_EMPTY);
     };
     const resolveFirstNonEmpty = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.FIRST_NON_EMPTY);
+        const response = _trigger(args, TriggerReturnType.FIRST_NON_EMPTY);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const untilTrue = (...args) => {
-        _trigger(args, types_1.TriggerReturnType.UNTIL_TRUE);
+        _trigger(args, TriggerReturnType.UNTIL_TRUE);
     };
     const untilFalse = (...args) => {
-        _trigger(args, types_1.TriggerReturnType.UNTIL_FALSE);
+        _trigger(args, TriggerReturnType.UNTIL_FALSE);
     };
     const pipe = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.PIPE);
+        return _trigger(args, TriggerReturnType.PIPE);
     };
     const resolvePipe = (...args) => {
-        const response = _trigger(args, types_1.TriggerReturnType.PIPE);
+        const response = _trigger(args, TriggerReturnType.PIPE);
         if (response instanceof Promise) {
             return response;
         }
         return Promise.resolve(response);
     };
     const raw = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.RAW);
+        return _trigger(args, TriggerReturnType.RAW);
     };
     const api = {
         addListener,

package/dist/eventBus.d.ts

@@ -66,25 +66,25 @@ export declare function createEventBus<EventsMap extends BaseEventMap = DefaultE
     readonly dispatch: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => void;
     readonly get: <K extends KeyOf<GetEventsMap<EventsMap>>>(name: K) => GetEventTypesMap<EventsMap>[K];
     readonly add: (name: MapKey, options?: EventOptions<BaseHandler>) => void;
-    readonly first: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => ReturnType<EventsMap[K]> | undefined>;
-    readonly resolveFirst: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>>;
-    readonly all: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => ReturnType<EventsMap[K]>[]>;
-    readonly resolveAll: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>>[]>>;
-    readonly resolve: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>>[]>>;
-    readonly last: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => ReturnType<EventsMap[K]> | undefined>;
-    readonly resolveLast: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>>;
-    readonly merge: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => ReturnType<EventsMap[K]> | undefined>;
-    readonly resolveMerge: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>>;
-    readonly concat: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => (ReturnType<EventsMap[K]> extends infer T ? T extends ReturnType<EventsMap[K]> ? T extends (infer U)[] ? U : T : never : never)[]>;
-    readonly resolveConcat: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<(Awaited<ReturnType<EventsMap[K]>> extends infer T ? T extends Awaited<ReturnType<EventsMap[K]>> ? T extends (infer U)[] ? U : T : never : never)[]>>;
-    readonly firstNonEmpty: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => ReturnType<EventsMap[K]> | undefined>;
-    readonly resolveFirstNonEmpty: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>>;
-    readonly untilTrue: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => void>;
-    readonly untilFalse: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => void>;
-    readonly pipe: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => ReturnType<EventsMap[K]> | undefined>;
-    readonly resolvePipe: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>>;
-    readonly raw: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => (ReturnType<EventsMap[K]> extends infer T ? T extends ReturnType<EventsMap[K]> ? T extends (infer U)[] ? U : T : never : never)[]>;
-    readonly withTags: <T extends (...args: any[]) => any>(tags: string[], callback: T) => ReturnType<T>;
+    readonly first: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["first"]>;
+    readonly resolveFirst: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveFirst"]>;
+    readonly all: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["all"]>;
+    readonly resolveAll: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveAll"]>;
+    readonly resolve: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveAll"]>;
+    readonly last: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["last"]>;
+    readonly resolveLast: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveLast"]>;
+    readonly merge: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["merge"]>;
+    readonly resolveMerge: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveMerge"]>;
+    readonly concat: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["concat"]>;
+    readonly resolveConcat: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveConcat"]>;
+    readonly firstNonEmpty: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["firstNonEmpty"]>;
+    readonly resolveFirstNonEmpty: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolveFirstNonEmpty"]>;
+    readonly untilTrue: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["untilTrue"]>;
+    readonly untilFalse: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["untilFalse"]>;
+    readonly pipe: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["pipe"]>;
+    readonly resolvePipe: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["resolvePipe"]>;
+    readonly raw: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<GetEventTypesMap<EventsMap>[K]["raw"]>;
+    readonly withTags: <R>(tags: string[], callback: () => R) => R;
     readonly intercept: (fn: InterceptorFunction) => void;
     readonly stopIntercepting: () => void;
     readonly isIntercepting: () => boolean;
@@ -94,14 +94,14 @@ export declare function createEventBus<EventsMap extends BaseEventMap = DefaultE
     readonly relay: ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }: {
         eventSource: RelaySource;
         remoteEventName: MapKey;
-        localEventName?: any;
+        localEventName?: MapKey | null;
         proxyType?: ProxyType;
         localEventNamePrefix?: string | null;
     }) => void;
     readonly unrelay: ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }: {
         eventSource: RelaySource;
         remoteEventName: MapKey;
-        localEventName?: any;
+        localEventName?: MapKey | null;
         proxyType?: ProxyType;
         localEventNamePrefix?: string | null;
     }) => void;