@kuindji/reactive 1.0.23 → 1.1.0

package/dist/event.js

@@ -1,11 +1,9 @@
-"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.js";
+import isPromiseLike from "./lib/isPromiseLike.js";
+import listenerSorter from "./lib/listenerSorter.js";
+import tagsIntersect from "./lib/tagsIntersect.js";
+import { TriggerReturnType } from "./lib/types.js";
+export function createEvent(eventOptions = {}) {
     let listeners = [];
     const errorListeners = [];
     let queue = [];
@@ -17,10 +15,12 @@ function createEvent(eventOptions = {}) {
     let currentTagsFilter = null;
     const options = Object.assign({ async: null, limit: null, autoTrigger: null, filter: null, filterContext: null, maxListeners: 0 }, eventOptions);
     const addListener = (handler, listenerOptions = {}) => {
+        var _a;
         if (!handler) {
             return;
         }
-        if (listeners.find((l) => l.handler === handler && l.context === listenerOptions.context)) {
+        const listenerContext = (_a = listenerOptions.context) !== null && _a !== void 0 ? _a : null;
+        if (listeners.find((l) => l.handler === handler && l.context === listenerContext)) {
             return;
         }
         if (options.maxListeners && listeners.length >= options.maxListeners) {
@@ -41,7 +41,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) {
@@ -57,8 +57,12 @@ function createEvent(eventOptions = {}) {
                 }
                 return false;
             };
-            _trigger(lastTrigger);
-            options.filter = prevFilter;
+            try {
+                _trigger(lastTrigger);
+            }
+            finally {
+                options.filter = prevFilter;
+            }
         }
     };
     const removeListener = (handler, context, tag) => {
@@ -83,6 +87,49 @@ function createEvent(eventOptions = {}) {
         listeners.splice(inx, 1);
         return true;
     };
+    const updateListenerOptions = (handler, context = null, nextOptions = {}) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const listenerContext = context !== null && context !== void 0 ? context : null;
+        const listener = listeners.find((l) => l.handler === handler && l.context === listenerContext);
+        if (!listener) {
+            return false;
+        }
+        const prevAlwaysFirst = listener.alwaysFirst;
+        const prevAlwaysLast = listener.alwaysLast;
+        // Soft fields, applying the same defaults as addListener so that a
+        // removed field resets to its default rather than lingering.
+        listener.limit = (_a = nextOptions.limit) !== null && _a !== void 0 ? _a : 0;
+        listener.start = (_b = nextOptions.start) !== null && _b !== void 0 ? _b : 1;
+        listener.tags = (_c = nextOptions.tags) !== null && _c !== void 0 ? _c : [];
+        listener.extraData = (_d = nextOptions.extraData) !== null && _d !== void 0 ? _d : null;
+        listener.alwaysFirst = (_e = nextOptions.alwaysFirst) !== null && _e !== void 0 ? _e : false;
+        listener.alwaysLast = (_f = nextOptions.alwaysLast) !== null && _f !== void 0 ? _f : false;
+        let nextAsync = (_g = nextOptions.async) !== null && _g !== void 0 ? _g : null;
+        if (nextAsync === true) {
+            nextAsync = 1;
+        }
+        listener.async = nextAsync;
+        // Re-sort if ordering hints changed. Unlike addListener we do NOT
+        // rewrite each listener's index here: the existing indices hold the
+        // original insertion order, and preserving them lets sorting restore
+        // that order when alwaysFirst/alwaysLast is cleared.
+        if (listener.alwaysFirst !== prevAlwaysFirst
+            || listener.alwaysLast !== prevAlwaysLast) {
+            if (listener.alwaysFirst === true || listener.alwaysLast === true) {
+                sortListeners = true;
+            }
+            if (sortListeners) {
+                listeners.sort((l1, l2) => listenerSorter(l1, l2));
+            }
+        }
+        // The core auto-remove check is a strict `called === limit`, so a
+        // listener whose `called` already exceeds the new limit would never
+        // auto-remove. Remove it immediately in that case.
+        if (listener.limit !== 0 && listener.called >= listener.limit) {
+            removeListener(listener.handler, listener.context);
+        }
+        return true;
+    };
     const hasListener = (handler, context, tag) => {
         if (handler) {
             return (listeners.findIndex((l) => {
@@ -140,7 +187,7 @@ function createEvent(eventOptions = {}) {
         queued = false;
         if (queue.length > 0) {
             for (let i = 0, l = queue.length; i < l; i++) {
-                _trigger(queue[i][0], queue[i][1]);
+                _trigger(queue[i][0], queue[i][1], queue[i][2]);
             }
             queue = [];
         }
@@ -159,7 +206,6 @@ function createEvent(eventOptions = {}) {
         triggered = 0;
         lastTrigger = null;
         sortListeners = false;
-        cachedPromise = null;
     };
     const _listenerCall = (listener, args, resolve = null) => {
         let isAsync = listener.async;
@@ -174,28 +220,31 @@ 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) {
-                    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);
+            if (isPromiseLike(result)) {
+                const handledResult = Promise.resolve(result).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;
+                    }
+                    return undefined;
+                });
+                if (resolve !== null) {
+                    void handledResult.then(resolve);
                 }
+                return handledResult;
+            }
+            if (resolve !== null) {
+                resolve(result);
             }
             return result;
         }
@@ -216,22 +265,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,8 +288,13 @@ function createEvent(eventOptions = {}) {
         return _listenerCall(listener, args);
     };
     const _trigger = (args, returnType = null, tags) => {
+        var _a, _b;
         if (queued) {
-            queue.push([args, returnType]);
+            queue.push([
+                args,
+                returnType,
+                (_b = (_a = (tags || currentTagsFilter)) === null || _a === void 0 ? void 0 : _a.slice()) !== null && _b !== void 0 ? _b : null,
+            ]);
             return;
         }
         if (suspended) {
@@ -256,24 +310,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 = [];
@@ -289,12 +343,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++;
@@ -306,9 +360,7 @@ function createEvent(eventOptions = {}) {
             if (isConsequent && results.length > 0) {
                 const prev = results[results.length - 1];
                 if (hasPromises) {
-                    const prevPromise = prev instanceof Promise
-                        ? prev
-                        : Promise.resolve(prev);
+                    const prevPromise = Promise.resolve(prev);
                     listenerResult = prevPromise.then(((listener, args, returnType) => (value) => {
                         return _listenerCallWPrev(listener, args, value, returnType);
                     })(listener, args, returnType));
@@ -326,26 +378,26 @@ 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)
+                            && !isPromiseLike(listenerResult)
                             && listenerResult !== null
                             && listenerResult !== undefined) {
                             return listenerResult;
@@ -354,13 +406,13 @@ function createEvent(eventOptions = {}) {
                     }
                 }
             }
-            if (!hasPromises && listenerResult instanceof Promise) {
+            if (!hasPromises && isPromiseLike(listenerResult)) {
                 hasPromises = true;
             }
             results.push(listenerResult);
         }
         switch (returnType) {
-            case types_1.TriggerReturnType.RAW: {
+            case TriggerReturnType.RAW: {
                 return results;
             }
             case undefined:
@@ -370,36 +422,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((r) => r.flat())
                     : results.flat();
             }
-            case types_1.TriggerReturnType.MERGE: {
+            case TriggerReturnType.MERGE: {
                 return hasPromises
                     ? 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: {
+            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];
             }
         }
@@ -408,104 +460,102 @@ function createEvent(eventOptions = {}) {
         _trigger(args);
     };
     const withTags = (tags, callback) => {
+        const prevTagsFilter = currentTagsFilter;
         currentTagsFilter = tags;
         try {
             return callback();
         }
         finally {
-            currentTagsFilter = null;
+            currentTagsFilter = prevTagsFilter;
         }
     };
-    let cachedPromise = null;
     const promise = (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);
+        return new Promise((resolve) => {
+            options = Object.assign(Object.assign({}, (options || {})), { limit: 1 });
+            const l = ((...args) => {
+                resolve(args);
             });
+            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);
-        if (response instanceof Promise) {
-            return response;
+        const response = _trigger(args, TriggerReturnType.FIRST);
+        if (isPromiseLike(response)) {
+            return Promise.resolve(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);
-        if (response instanceof Promise) {
-            return response;
+        const response = _trigger(args, TriggerReturnType.ALL);
+        if (isPromiseLike(response)) {
+            return Promise.resolve(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);
-        if (response instanceof Promise) {
-            return response;
+        const response = _trigger(args, TriggerReturnType.LAST);
+        if (isPromiseLike(response)) {
+            return Promise.resolve(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);
-        if (response instanceof Promise) {
-            return response;
+        const response = _trigger(args, TriggerReturnType.MERGE);
+        if (isPromiseLike(response)) {
+            return Promise.resolve(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);
-        if (response instanceof Promise) {
-            return response;
+        const response = _trigger(args, TriggerReturnType.CONCAT);
+        if (isPromiseLike(response)) {
+            return Promise.resolve(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);
-        if (response instanceof Promise) {
-            return response;
+        const response = _trigger(args, TriggerReturnType.FIRST_NON_EMPTY);
+        if (isPromiseLike(response)) {
+            return Promise.resolve(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);
-        if (response instanceof Promise) {
-            return response;
+        const response = _trigger(args, TriggerReturnType.PIPE);
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
     const raw = (...args) => {
-        return _trigger(args, types_1.TriggerReturnType.RAW);
+        return _trigger(args, TriggerReturnType.RAW);
     };
     const api = {
         addListener,
@@ -516,6 +566,7 @@ function createEvent(eventOptions = {}) {
         /** @alias addListener */
         subscribe: addListener,
         removeListener,
+        updateListenerOptions,
         /** @alias removeListener */
         un: removeListener,
         /** @alias removeListener */

package/dist/eventBus.d.ts

@@ -1,6 +1,6 @@
-import { createEvent } from "./event";
-import type { EventDefinitionHelper, EventOptions, ListenerOptions } from "./event";
-import { ApiType, BaseHandler, ErrorListenerSignature, KeyOf, MapKey, ProxyType, TriggerReturnType } from "./lib/types";
+import { createEvent } from "./event.js";
+import type { EventDefinitionHelper, EventOptions, ListenerOptions } from "./event.js";
+import { ApiType, BaseHandler, ErrorListenerSignature, KeyOf, MapKey, ProxyType, TriggerReturnType } from "./lib/types.js";
 type InterceptorFunction = (name: MapKey, args: any[], tags: string[] | null, returnType: TriggerReturnType | null) => boolean;
 type RelaySource = {
     on: (name: any, fn: (...args: any[]) => any, options?: ListenerOptions) => void;
@@ -59,6 +59,7 @@ export declare function createEventBus<EventsMap extends BaseEventMap = DefaultE
     readonly remove: <K extends KeyOf<GetEventsMap<EventsMap>>, H extends GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
     /** @alias removeListener */
     readonly unsubscribe: <K extends KeyOf<GetEventsMap<EventsMap>>, H extends GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly updateListenerOptions: <K extends KeyOf<GetEventsMap<EventsMap>>, H extends GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, context?: object | null, nextOptions?: ListenerOptions) => boolean;
     readonly trigger: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => void;
     /** @alias trigger */
     readonly emit: <K extends KeyOf<GetEventsMap<EventsMap>>, A extends GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => void;
@@ -66,6 +67,7 @@ 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 setOptions: (options?: EventBusOptions<BaseEventMap>) => void;
     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"]>;