@kuindji/reactive 1.0.24 → 1.2.0

package/dist/event.js

@@ -1,29 +1,45 @@
-import asyncCall from "./lib/asyncCall";
-import listenerSorter from "./lib/listenerSorter";
-import tagsIntersect from "./lib/tagsIntersect";
-import { TriggerReturnType } from "./lib/types";
+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 = [];
     let suspended = false;
     let queued = false;
+    let destroyed = false;
     let triggered = 0;
     let lastTrigger = null;
+    // The args replayed to a late autoTrigger listener. Recorded only while
+    // autoTrigger is enabled, so enabling it *after* a trigger does not replay
+    // that earlier (pre-enablement) trigger. Kept separate from `lastTrigger`,
+    // which is recorded on every trigger purely for `lastTriggerArgs`.
+    let autoTriggerArgs = null;
     let sortListeners = false;
     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, _b;
+        if (destroyed) {
+            throw new Error("Event is destroyed");
+        }
         if (!handler) {
             return;
         }
-        if (listeners.find((l) => l.handler === handler && l.context === listenerOptions.context)) {
+        const signal = (_a = listenerOptions.signal) !== null && _a !== void 0 ? _a : null;
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            return;
+        }
+        const listenerContext = (_b = listenerOptions.context) !== null && _b !== void 0 ? _b : null;
+        if (listeners.find((l) => l.handler === handler && l.context === listenerContext)) {
             return;
         }
         if (options.maxListeners && listeners.length >= options.maxListeners) {
             throw new Error(`Max listeners (${options.maxListeners}) reached`);
         }
-        const listener = Object.assign({ handler, called: 0, count: 0, index: listeners.length, start: 1, context: null, tags: [], extraData: null, first: false, alwaysFirst: false, alwaysLast: false, limit: 0, async: null }, listenerOptions);
+        const listener = Object.assign(Object.assign({ handler, called: 0, count: 0, index: listeners.length, start: 1, context: null, tags: [], extraData: null, first: false, alwaysFirst: false, alwaysLast: false, limit: 0, async: null }, listenerOptions), { abortCleanup: null });
         if (listener.async === true) {
             listener.async = 1;
         }
@@ -44,21 +60,32 @@ export function createEvent(eventOptions = {}) {
             || (listenerOptions === null || listenerOptions === void 0 ? void 0 : listenerOptions.alwaysLast) === true) {
             sortListeners = true;
         }
+        if (signal) {
+            const onAbort = () => {
+                removeListener(handler, listenerContext);
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            listener.abortCleanup = () => {
+                signal.removeEventListener("abort", onAbort);
+            };
+        }
         if (options.autoTrigger
-            && lastTrigger !== null
+            && autoTriggerArgs !== null
             && !suspended) {
-            const prevFilter = options.filter;
-            options.filter = (args, l) => {
-                if (l && l.handler === handler) {
-                    return prevFilter ? prevFilter(args, l) !== false : true;
-                }
-                return false;
-            };
-            _trigger(lastTrigger);
-            options.filter = prevFilter;
+            // Replay the last enabled trigger, but only into the listener just
+            // added. The replay target is passed explicitly to `_trigger` (not
+            // via shared closure/`options.filter` state) so that a real trigger
+            // fired synchronously by the replayed handler is an ordinary real
+            // trigger — full bookkeeping, limit enforcement, and delivery to all
+            // listeners — rather than inheriting this replay's suppression.
+            _trigger(autoTriggerArgs, null, null, {
+                handler,
+                context: listenerContext !== null && listenerContext !== void 0 ? listenerContext : null,
+            });
         }
     };
     const removeListener = (handler, context, tag) => {
+        var _a;
         const inx = listeners.findIndex((l) => {
             if (l.handler !== handler) {
                 return false;
@@ -77,7 +104,92 @@ export function createEvent(eventOptions = {}) {
         if (inx === -1) {
             return false;
         }
-        listeners.splice(inx, 1);
+        const [removed] = listeners.splice(inx, 1);
+        (_a = removed === null || removed === void 0 ? void 0 : removed.abortCleanup) === null || _a === void 0 ? void 0 : _a.call(removed);
+        return true;
+    };
+    const updateListenerOptions = (handler, context = null, nextOptions = {}) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        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;
+        // Partial update: only fields explicitly present in nextOptions change;
+        // any omitted field keeps its current value (a caller changing one
+        // option does not silently reset the others). Pass a field explicitly
+        // (e.g. limit: 0, signal: null) to clear it.
+        if ("limit" in nextOptions) {
+            listener.limit = (_a = nextOptions.limit) !== null && _a !== void 0 ? _a : 0;
+        }
+        if ("start" in nextOptions) {
+            listener.start = (_b = nextOptions.start) !== null && _b !== void 0 ? _b : 1;
+        }
+        if ("tags" in nextOptions) {
+            listener.tags = (_c = nextOptions.tags) !== null && _c !== void 0 ? _c : [];
+        }
+        if ("extraData" in nextOptions) {
+            listener.extraData = (_d = nextOptions.extraData) !== null && _d !== void 0 ? _d : null;
+        }
+        if ("alwaysFirst" in nextOptions) {
+            listener.alwaysFirst = (_e = nextOptions.alwaysFirst) !== null && _e !== void 0 ? _e : false;
+        }
+        if ("alwaysLast" in nextOptions) {
+            listener.alwaysLast = (_f = nextOptions.alwaysLast) !== null && _f !== void 0 ? _f : false;
+        }
+        if ("async" in nextOptions) {
+            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));
+            }
+        }
+        // Rebind the AbortSignal only when `signal` is explicitly present:
+        // detach any previous wiring so the old controller can no longer remove
+        // this listener, then attach the new signal. Omitting the field leaves
+        // the existing binding intact (partial-update convention); pass
+        // signal: null to clear it. An already-aborted new signal removes the
+        // listener now, mirroring addListener's "do not keep an aborted-signal
+        // listener".
+        if ("signal" in nextOptions) {
+            (_h = listener.abortCleanup) === null || _h === void 0 ? void 0 : _h.call(listener);
+            listener.abortCleanup = null;
+            const nextSignal = (_j = nextOptions.signal) !== null && _j !== void 0 ? _j : null;
+            if (nextSignal) {
+                if (nextSignal.aborted) {
+                    removeListener(listener.handler, listenerContext);
+                    return true;
+                }
+                const onAbort = () => {
+                    removeListener(listener.handler, listenerContext);
+                };
+                nextSignal.addEventListener("abort", onAbort, { once: true });
+                listener.abortCleanup = () => {
+                    nextSignal.removeEventListener("abort", onAbort);
+                };
+            }
+        }
+        // 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) => {
@@ -105,10 +217,16 @@ export function createEvent(eventOptions = {}) {
     const removeAllListeners = (tag) => {
         if (tag) {
             listeners = listeners.filter((l) => {
-                return !l.tags || l.tags.indexOf(tag) === -1;
+                var _a;
+                const keep = !l.tags || l.tags.indexOf(tag) === -1;
+                if (!keep) {
+                    (_a = l.abortCleanup) === null || _a === void 0 ? void 0 : _a.call(l);
+                }
+                return keep;
             });
         }
         else {
+            listeners.forEach((l) => { var _a; return (_a = l.abortCleanup) === null || _a === void 0 ? void 0 : _a.call(l); });
             listeners = [];
         }
     };
@@ -137,7 +255,7 @@ export 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 = [];
         }
@@ -147,7 +265,98 @@ export function createEvent(eventOptions = {}) {
     };
     const isSuspended = () => suspended;
     const isQueued = () => queued;
+    // One-call teardown: drop all listeners (unwinding their abort handlers via
+    // reset) and mark the event dead. Post-destroy trigger/addListener throw
+    // rather than silently no-op, surfacing use-after-free.
+    const destroy = () => {
+        reset();
+        destroyed = true;
+    };
+    const isDestroyed = () => destroyed;
+    const listenerCount = (tag) => {
+        if (tag) {
+            return listeners.filter((l) => l.tags && l.tags.indexOf(tag) !== -1).length;
+        }
+        return listeners.length;
+    };
+    const triggeredCount = () => triggered;
+    // Return a copy: handing back the internal `lastTrigger` reference would let
+    // a caller mutate it, corrupting both the recorded snapshot and the values
+    // replayed to autoTrigger listeners.
+    const lastTriggerArgs = () => lastTrigger ? lastTrigger.slice() : null;
+    // Deep-copy extraData so the read-only projection cannot mutate internal
+    // listener metadata (which filters can read) at any depth; a shallow copy
+    // still shares nested containers by reference. `seen` carries already-cloned
+    // containers so a cyclic graph reuses its clone instead of recursing forever
+    // (a plain recursive clone throws RangeError on cycles). Arrays, plain
+    // objects, Date, Map and Set are cloned. Truly opaque values (functions,
+    // class instances) are returned as-is — copying their enumerable keys would
+    // not faithfully reproduce them — as are primitives.
+    const projectExtraDataDeep = (value, seen) => {
+        if (value === null || typeof value !== "object") {
+            return value;
+        }
+        const existing = seen.get(value);
+        if (existing !== undefined) {
+            return existing;
+        }
+        if (value instanceof Date) {
+            return new Date(value.getTime());
+        }
+        if (Array.isArray(value)) {
+            const copy = [];
+            seen.set(value, copy);
+            for (const v of value) {
+                copy.push(projectExtraDataDeep(v, seen));
+            }
+            return copy;
+        }
+        if (value instanceof Map) {
+            const copy = new Map();
+            seen.set(value, copy);
+            value.forEach((v, k) => {
+                copy.set(projectExtraDataDeep(k, seen), projectExtraDataDeep(v, seen));
+            });
+            return copy;
+        }
+        if (value instanceof Set) {
+            const copy = new Set();
+            seen.set(value, copy);
+            value.forEach((v) => {
+                copy.add(projectExtraDataDeep(v, seen));
+            });
+            return copy;
+        }
+        const proto = Object.getPrototypeOf(value);
+        if (proto === Object.prototype || proto === null) {
+            const copy = {};
+            seen.set(value, copy);
+            for (const k of Object.keys(value)) {
+                copy[k] = projectExtraDataDeep(value[k], seen);
+            }
+            return copy;
+        }
+        return value;
+    };
+    const projectExtraData = (value) => projectExtraDataDeep(value, new WeakMap());
+    const getListeners = () => {
+        return listeners.map((l) => ({
+            handler: l.handler,
+            context: l.context,
+            tags: l.tags ? l.tags.slice() : [],
+            limit: l.limit,
+            start: l.start,
+            called: l.called,
+            count: l.count,
+            async: l.async,
+            first: l.first,
+            alwaysFirst: l.alwaysFirst,
+            alwaysLast: l.alwaysLast,
+            extraData: projectExtraData(l.extraData),
+        }));
+    };
     const reset = () => {
+        listeners.forEach((l) => { var _a; return (_a = l.abortCleanup) === null || _a === void 0 ? void 0 : _a.call(l); });
         listeners.length = 0;
         errorListeners.length = 0;
         queue.length = 0;
@@ -155,8 +364,8 @@ export function createEvent(eventOptions = {}) {
         queued = false;
         triggered = 0;
         lastTrigger = null;
+        autoTriggerArgs = null;
         sortListeners = false;
-        cachedPromise = null;
     };
     const _listenerCall = (listener, args, resolve = null) => {
         let isAsync = listener.async;
@@ -173,26 +382,29 @@ export function createEvent(eventOptions = {}) {
             const result = isAsync !== false
                 ? 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;
         }
@@ -214,6 +426,12 @@ export function createEvent(eventOptions = {}) {
     };
     const _listenerCallWPrev = (listener, args, prevValue, returnType) => {
         if (returnType === TriggerReturnType.PIPE) {
+            // Copy-on-write: preserve the pre-pipe lastTrigger snapshot before
+            // mutating args[0] in place for the pipe chain (lastTrigger stores
+            // the args reference rather than an eager per-trigger copy).
+            if (lastTrigger === args) {
+                lastTrigger = args.slice();
+            }
             args[0] = prevValue;
             // since we don't user listener's arg transformer,
             // we don't need to prepare args
@@ -235,20 +453,49 @@ export function createEvent(eventOptions = {}) {
         }
         return _listenerCall(listener, args);
     };
-    const _trigger = (args, returnType = null, tags) => {
+    const _trigger = (args, returnType = null, tags, 
+    // When set, this call is an autoTrigger replay: it must not bump
+    // `triggered`/`lastTrigger` or be gated by the trigger `limit`, and it is
+    // delivered only to the listener identified here.
+    replayTo) => {
+        var _a, _b, _c;
+        const replaying = !!replayTo;
+        if (destroyed) {
+            throw new Error("Event is destroyed");
+        }
         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) {
             return;
         }
-        if (options.limit && triggered >= options.limit) {
+        // The trigger `limit` bounds real triggers; an autoTrigger replay is an
+        // internal redelivery and must always reach the new listener.
+        if (options.limit && triggered >= options.limit && !replaying) {
             return;
         }
-        triggered++;
-        if (options.autoTrigger) {
-            lastTrigger = args.slice();
+        if (!replaying) {
+            triggered++;
+            // Record the last trigger arguments for introspection
+            // (`lastTriggerArgs`). Store the reference rather than eagerly
+            // copying on every trigger (a hot path even when nothing ever reads
+            // it): `args` is a fresh per-call array the caller cannot reach, and
+            // listeners receive it spread (never the array itself). The snapshot
+            // is copied lazily — when handed out by lastTriggerArgs(), and
+            // copy-on-write before PIPE mode mutates args[0] in place — so the
+            // recorded snapshot stays the pre-pipe arguments.
+            lastTrigger = args;
+            // Record the replay source only while autoTrigger is enabled, so a
+            // late listener added after autoTrigger is turned on replays the
+            // most recent *enabled* trigger, never an earlier disabled one.
+            if (options.autoTrigger) {
+                autoTriggerArgs = args.slice();
+            }
         }
         // in pipe mode if there is no listeners,
         // we just return piped value
@@ -279,6 +526,13 @@ export function createEvent(eventOptions = {}) {
             if (!listener) {
                 continue;
             }
+            // An autoTrigger replay is delivered only to the newly added
+            // listener identified by `replayTo`.
+            if (replayTo
+                && (listener.handler !== replayTo.handler
+                    || ((_c = listener.context) !== null && _c !== void 0 ? _c : null) !== replayTo.context)) {
+                continue;
+            }
             if (options.filter
                 && options.filter.call(options.filterContext, args, listener)
                     === false) {
@@ -300,12 +554,20 @@ export function createEvent(eventOptions = {}) {
                 && listener.count < listener.start) {
                 continue;
             }
+            // Count the call and exhaust the limit BEFORE invoking the handler.
+            // If the handler re-triggers this same event, the nested _trigger
+            // snapshots `listeners` AFTER the removal below, so an exhausted
+            // (e.g. once()) listener is not invoked a second time. Doing this
+            // after the call would let a re-entrant trigger see the still-live
+            // listener and run it again past its limit.
+            listener.called++;
+            if (listener.called === listener.limit) {
+                removeListener(listener.handler, listener.context);
+            }
             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));
@@ -319,10 +581,6 @@ export function createEvent(eventOptions = {}) {
             else {
                 listenerResult = _listenerCall(listener, args);
             }
-            listener.called++;
-            if (listener.called === listener.limit) {
-                removeListener(listener.handler, listener.context);
-            }
             if (returnType === TriggerReturnType.FIRST) {
                 return listenerResult;
             }
@@ -342,7 +600,7 @@ export function createEvent(eventOptions = {}) {
                     }
                     case TriggerReturnType.FIRST_NON_EMPTY: {
                         if (!hasPromises
-                            && !(listenerResult instanceof Promise)
+                            && !isPromiseLike(listenerResult)
                             && listenerResult !== null
                             && listenerResult !== undefined) {
                             return listenerResult;
@@ -351,7 +609,7 @@ export function createEvent(eventOptions = {}) {
                     }
                 }
             }
-            if (!hasPromises && listenerResult instanceof Promise) {
+            if (!hasPromises && isPromiseLike(listenerResult)) {
                 hasPromises = true;
             }
             results.push(listenerResult);
@@ -405,33 +663,34 @@ export 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 once = (handler, listenerOptions = {}) => {
+        return addListener(handler, Object.assign(Object.assign({}, listenerOptions), { limit: 1 }));
+    };
     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, TriggerReturnType.FIRST);
     };
     const resolveFirst = (...args) => {
         const response = _trigger(args, TriggerReturnType.FIRST);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -440,8 +699,8 @@ export function createEvent(eventOptions = {}) {
     };
     const resolveAll = (...args) => {
         const response = _trigger(args, TriggerReturnType.ALL);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -450,8 +709,8 @@ export function createEvent(eventOptions = {}) {
     };
     const resolveLast = (...args) => {
         const response = _trigger(args, TriggerReturnType.LAST);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -460,8 +719,8 @@ export function createEvent(eventOptions = {}) {
     };
     const resolveMerge = (...args) => {
         const response = _trigger(args, TriggerReturnType.MERGE);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -470,8 +729,8 @@ export function createEvent(eventOptions = {}) {
     };
     const resolveConcat = (...args) => {
         const response = _trigger(args, TriggerReturnType.CONCAT);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -480,8 +739,8 @@ export function createEvent(eventOptions = {}) {
     };
     const resolveFirstNonEmpty = (...args) => {
         const response = _trigger(args, TriggerReturnType.FIRST_NON_EMPTY);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -496,8 +755,8 @@ export function createEvent(eventOptions = {}) {
     };
     const resolvePipe = (...args) => {
         const response = _trigger(args, TriggerReturnType.PIPE);
-        if (response instanceof Promise) {
-            return response;
+        if (isPromiseLike(response)) {
+            return Promise.resolve(response);
         }
         return Promise.resolve(response);
     };
@@ -512,7 +771,9 @@ export function createEvent(eventOptions = {}) {
         listen: addListener,
         /** @alias addListener */
         subscribe: addListener,
+        once,
         removeListener,
+        updateListenerOptions,
         /** @alias removeListener */
         un: removeListener,
         /** @alias removeListener */
@@ -536,8 +797,14 @@ export function createEvent(eventOptions = {}) {
         resume,
         setOptions,
         reset,
+        destroy,
+        isDestroyed,
         isSuspended,
         isQueued,
+        listenerCount,
+        triggeredCount,
+        lastTriggerArgs,
+        getListeners,
         withTags,
         promise,
         first,