@kuindji/reactive 1.0.23 → 1.1.0

package/README.md

@@ -161,11 +161,13 @@ const value = event.pipe(1); // value = 4
   - **Aliases**: `on()`, `listen()`, `subscribe()`
 - `removeListener(listener, context?, tag?)` - Remove specific listener
   - **Aliases**: `un()`, `off()`, `remove()`, `unsubscribe()`
+- `updateListenerOptions(listener, context?, nextOptions?)` - Update a registered listener's soft options (`limit`, `start`, `async`, `tags`, `extraData`, `alwaysFirst`/`alwaysLast`) **in place**, preserving its `called`/`count` counters. Matches the listener by `listener` + `context`. Returns `true` if a listener was found. `context` is an identity field and is not updated here (resubscribe to change it); `first` is insertion-time only and ignored. Lowering `limit` to at/below the current `called` removes the listener immediately.
 - `hasListener(listener?, context?, tag?)` - Check if listener exists
   - **Aliases**: `has()`
 - `removeAllListeners(tag?)` - Remove all listeners (optionally by tag)
 - `trigger(...args)` - Trigger the event
   - **Aliases**: `emit()`, `dispatch()`
+- `setOptions(options)` - Update event options in place. Accepts any `EventOptions` field (`async`, `limit`, `autoTrigger`, `filter`, `filterContext`, `maxListeners`). Does not reset the internal `triggered` count.
 
 #### Collector Methods
 
@@ -481,10 +483,12 @@ customSource.trigger("appStart");
 - `once(name, handler, options?)` - Add one-time listener
 - `removeListener(name, handler, context?, tag?)` - Remove listener
   - **Aliases**: `un()`, `off()`, `remove()`, `unsubscribe()`
+- `updateListenerOptions(name, handler, context?, nextOptions?)` - Update a registered listener's soft options in place (see Event's `updateListenerOptions`). Returns `false` if the event does not exist.
 - `trigger(name, ...args)` - Trigger specific event
   - **Aliases**: `emit()`, `dispatch()`
 - `get(name)` - Get event instance by name
 - `add(name, options?)` - Add new event to bus
+- `setOptions(options?)` - Update bus options. Present per-event entries in `eventOptions` are applied to already-created events via `event.setOptions`, and future events use the latest stored options. A removed event-name entry leaves the existing event unchanged.
 
 #### Collector Methods
 
@@ -560,27 +564,31 @@ const result = await fetchUserAction.invoke("user123");
 #### Core Methods
 
 - `invoke(...args)` - Execute the action
+- `setAction(fn)` - Replace the action function in place. Subsequent `invoke()` calls use the new function; all response, before-action and error listeners are preserved (they live in separate events). The replacement must keep a compatible signature.
 - `addListener(handler, options?)` - Add response listener
   - **Aliases**: `on()`, `listen()`, `subscribe()`
 - `removeListener(handler, context?, tag?)` - Remove listener
   - **Aliases**: `un()`, `off()`, `remove()`, `unsubscribe()`
-- `hasListener(handler?, context?, tag?)` - Check if listener exists
-  - **Aliases**: `has()`
+- `updateListenerOptions(handler, context?, nextOptions?)` - Update a response listener's soft options in place (see Event's `updateListenerOptions`)
 - `removeAllListeners(tag?)` - Remove all listeners
 
 #### Error Handling
 
 - `addErrorListener(handler, context?)` - Add error listener
 - `removeErrorListener(handler, context?)` - Remove error listener
-- `hasErrorListeners()` - Check if error listeners exist
 - `removeAllErrorListeners(tag?)` - Remove all error listeners
 
 #### Utility Methods
 
 - `promise(options?)` - Get promise for next invocation
-- `suspend(withQueue?)` - Suspend action execution
-- `resume()` - Resume action execution
-- `reset()` - Reset action state
+- `beforeActionPromise(options?)` - Get promise for the next before-action call
+- `errorPromise(options?)` - Get promise for the next action error
+
+#### Before Action Methods
+
+- `addBeforeActionListener(handler, options?)` - Add listener that runs before invocation
+- `removeBeforeActionListener(handler, context?, tag?)` - Remove before-action listener
+- `removeAllBeforeActionListeners(tag?)` - Remove all before-action listeners
 
 ## ActionMap
 
@@ -683,7 +691,10 @@ const user = await actionBus.invoke("fetchUser", "user123");
 
 #### Core Methods
 
-- `add(name, action)` - Add action to bus
+- `add(name, action)` - Add action to bus (no-op if it already exists)
+- `replace(name, action)` - Replace an existing action's function in place via `setAction` (preserving its listeners and the bus error-forwarding listener); adds it if the name is new
+- `removeAction(name)` - Remove an action from the bus (named `removeAction` because `remove` is an alias for `removeListener`). Afterwards `invoke`/`on`/`un` for that name throw `Action <name> not found`.
+- `has(name)` - Check if action exists
 - `get(name)` - Get action by name
 - `invoke(name, ...args)` - Invoke action by name
 - `addListener(name, handler, options?)` - Add listener to action
@@ -691,8 +702,7 @@ const user = await actionBus.invoke("fetchUser", "user123");
 - `once(name, handler, options?)` - Add one-time listener
 - `removeListener(name, handler, context?, tag?)` - Remove listener
   - **Aliases**: `un()`, `off()`, `remove()`, `unsubscribe()`
-- `has(name)` - Check if action exists
-- `remove(name)` - Remove action
+- `updateListenerOptions(name, handler, context?, nextOptions?)` - Update a response listener's soft options in place (see Event's `updateListenerOptions`)
 
 #### Error Handling
 
@@ -753,11 +763,13 @@ const userData = userStore.get([ "name", "email" ]); // { name: string, email: s
 - `get(keys)` - Get multiple properties
 - `isEmpty()` - Check if store is empty
 - `getData()` - Get all store data
-- `reset()` - Reset store to initial state
+- `reset()` - Clear store data
 
 #### Event Methods
 
-- `onChange(key, handler)` - Listen to property changes
+- `onChange(key, handler, options?)` - Listen to property changes
+- `removeOnChange(key, handler, context?, tag?)` - Remove a change listener
+- `updateOnChangeOptions(key, handler, context?, nextOptions?)` - Update a change listener's soft options in place (see Event's `updateListenerOptions`)
 - `pipe(key, handler)` - Add data transformation pipeline
 - `control(event, handler)` - Control store events
 
@@ -953,6 +965,17 @@ useListenToStoreChanges(
 )
 ```
 
+### Reconciliation across renders
+
+Hook inputs are reconciled on every render using semantic comparison, so you
+can safely pass inline objects (e.g. `{ tags: [tag] }`) without object identity
+forcing a resubscribe:
+
+- **Listener options** (`useListenToEvent`/`useListenToEventBus`/`useListenToActionBus`/`useListenToStoreChanges`) are compared field by field (`tags` is an order-insensitive set). A semantically equal object is a no-op. A changed soft option updates the live listener **in place**, preserving its `called`/`count` counters. Changing `context` (an identity field) resubscribes using the old context.
+- **`useEvent` event options** and **`useEventBus` options** are reconciled via `setOptions` instead of being ignored (and `useEventBus` no longer throws when options change).
+- **`useAction`/`useActionBus`/`useActionMap` action functions** are replaced in place via `setAction` (compared by reference), preserving all listeners; `useActionBus` also adds/removes actions as its map changes. The `useActionMap` key set is fixed by its type contract — a runtime key-set change throws.
+- **`useStore` config** (`onChange`/`pipes`/`control`) is reconciled by category + key (functions compared by reference); only handlers added by the hook are touched. **`initialData` is seed-only** — it initializes the store once and later changes are intentionally ignored (live data is owned by `set`/`useStoreState`).
+
 ## ErrorBoundary
 
 ### Description

package/dist/action.d.ts

@@ -1,4 +1,4 @@
-import type { ApiType, BaseHandler, ErrorListenerSignature, ErrorResponse } from "./lib/types";
+import type { ApiType, BaseHandler, ErrorListenerSignature, ErrorResponse } from "./lib/types.js";
 export type ActionResponse<Response = any, Args extends unknown[] = unknown[]> = {
     response: Response;
     error: null;
@@ -24,13 +24,14 @@ export type ActionDefinitionHelper<A extends BaseHandler> = {
 };
 export declare function createAction<A extends BaseHandler>(action: A): ApiType<ActionDefinitionHelper<A>, {
     readonly invoke: (...args: Parameters<A>) => Promise<ActionResponse<Awaited<ReturnType<A>>, Parameters<A>>>;
-    readonly addListener: (handler: ListenerSignature<A>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly setAction: (nextAction: A) => void;
+    readonly addListener: (handler: ListenerSignature<A>, listenerOptions?: import("./event.js").ListenerOptions) => void;
     /** @alias addListener */
-    readonly on: (handler: ListenerSignature<A>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly on: (handler: ListenerSignature<A>, listenerOptions?: import("./event.js").ListenerOptions) => void;
     /** @alias addListener */
-    readonly subscribe: (handler: ListenerSignature<A>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly subscribe: (handler: ListenerSignature<A>, listenerOptions?: import("./event.js").ListenerOptions) => void;
     /** @alias addListener */
-    readonly listen: (handler: ListenerSignature<A>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly listen: (handler: ListenerSignature<A>, listenerOptions?: import("./event.js").ListenerOptions) => void;
     readonly removeAllListeners: (tag?: string) => void;
     readonly removeListener: (handler: ListenerSignature<A>, context?: object | null, tag?: string | null) => boolean;
     /** @alias removeListener */
@@ -41,15 +42,16 @@ export declare function createAction<A extends BaseHandler>(action: A): ApiType<
     readonly remove: (handler: ListenerSignature<A>, context?: object | null, tag?: string | null) => boolean;
     /** @alias removeListener */
     readonly unsubscribe: (handler: ListenerSignature<A>, context?: object | null, tag?: string | null) => boolean;
-    readonly promise: (options?: import("./event").ListenerOptions) => Promise<[arg: ActionResponse<Awaited<ReturnType<A>>, Parameters<A>>]>;
-    readonly addErrorListener: (handler: ErrorListenerSignature<Parameters<A>>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly updateListenerOptions: (handler: ListenerSignature<A>, context?: object | null, nextOptions?: import("./event.js").ListenerOptions) => boolean;
+    readonly promise: (options?: import("./event.js").ListenerOptions) => Promise<[arg: ActionResponse<Awaited<ReturnType<A>>, Parameters<A>>]>;
+    readonly addErrorListener: (handler: ErrorListenerSignature<Parameters<A>>, listenerOptions?: import("./event.js").ListenerOptions) => void;
     readonly removeAllErrorListeners: (tag?: string) => void;
     readonly removeErrorListener: (handler: ErrorListenerSignature<Parameters<A>>, context?: object | null, tag?: string | null) => boolean;
-    readonly errorPromise: (options?: import("./event").ListenerOptions) => Promise<[errorResponse: ErrorResponse<Parameters<A>>]>;
-    readonly addBeforeActionListener: (handler: BeforeActionSignature<A>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly errorPromise: (options?: import("./event.js").ListenerOptions) => Promise<[errorResponse: ErrorResponse<Parameters<A>>]>;
+    readonly addBeforeActionListener: (handler: BeforeActionSignature<A>, listenerOptions?: import("./event.js").ListenerOptions) => void;
     readonly removeAllBeforeActionListeners: (tag?: string) => void;
     readonly removeBeforeActionListener: (handler: BeforeActionSignature<A>, context?: object | null, tag?: string | null) => boolean;
-    readonly beforeActionPromise: (options?: import("./event").ListenerOptions) => Promise<Parameters<A>>;
+    readonly beforeActionPromise: (options?: import("./event.js").ListenerOptions) => Promise<Parameters<A>>;
 }>;
 export type BaseActionDefinition = ActionDefinitionHelper<(...args: [any]) => any>;
 export type BaseAction = ReturnType<typeof createAction<(...args: [any]) => any>>;

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,20 +7,23 @@ 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.js";
+import isPromiseLike from "./lib/isPromiseLike.js";
+export function createAction(action) {
+    // The action function is held in a mutable variable so it can be swapped in
+    // place via setAction without disturbing any listeners (response, before
+    // and error listeners live in separate events independent of the function).
+    let actionFn = action;
+    const { trigger, addListener, removeAllListeners, removeListener, updateListenerOptions, 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);
-            for (let before of beforeResults) {
-                if (before instanceof Promise) {
-                    before = yield before;
-                }
+            const beforeResponse = triggerBeforeAction(...args);
+            const beforeResults = isPromiseLike(beforeResponse)
+                ? yield Promise.resolve(beforeResponse)
+                : beforeResponse;
+            for (const before of beforeResults) {
                 if (before === false) {
                     const response = {
                         response: null,
@@ -32,9 +34,9 @@ function createAction(action) {
                     return response;
                 }
             }
-            let result = action(...args);
-            if (result instanceof Promise) {
-                result = yield result;
+            let result = actionFn(...args);
+            if (isPromiseLike(result)) {
+                result = yield Promise.resolve(result);
             }
             const response = {
                 response: result,
@@ -64,8 +66,12 @@ function createAction(action) {
             return response;
         }
     });
+    const setAction = (nextAction) => {
+        actionFn = nextAction;
+    };
     const api = {
         invoke,
+        setAction,
         addListener,
         /** @alias addListener */
         on: addListener,
@@ -83,6 +89,7 @@ function createAction(action) {
         remove: removeListener,
         /** @alias removeListener */
         unsubscribe: removeListener,
+        updateListenerOptions,
         promise,
         addErrorListener,
         removeAllErrorListeners,

package/dist/actionBus.d.ts

@@ -1,6 +1,6 @@
-import { ActionDefinitionHelper, createAction } from "./action";
-import { ListenerOptions } from "./event";
-import type { ApiType, BaseHandler, ErrorListenerSignature, KeyOf, MapKey } from "./lib/types";
+import { ActionDefinitionHelper, createAction } from "./action.js";
+import { ListenerOptions } from "./event.js";
+import type { ApiType, BaseHandler, ErrorListenerSignature, KeyOf, MapKey } from "./lib/types.js";
 export interface BaseActionsMap {
     [key: MapKey]: BaseHandler;
 }
@@ -16,8 +16,11 @@ export type ActionBusDefinitionHelper<ActionsMap extends BaseActionsMap> = {
 };
 export declare function createActionBus<ActionsMap extends BaseActionsMap>(initialActions?: ActionsMap, errorListener?: ErrorListenerSignature<any[]>): ApiType<ActionBusDefinitionHelper<ActionsMap>, {
     readonly add: (name: MapKey, action: BaseHandler) => void;
+    readonly replace: (name: MapKey, action: BaseHandler) => void;
+    readonly removeAction: (name: MapKey) => void;
+    readonly has: (name: MapKey) => boolean;
     readonly get: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K) => GetActionTypesMap<ActionsMap>[K];
-    readonly invoke: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, ...args: GetActionDefinitionsMap<ActionsMap>[K]["actionArguments"]) => Promise<import("./action").ActionResponse<Awaited<ReturnType<ActionsMap[K]>>, Parameters<ActionsMap[K]>>>;
+    readonly invoke: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, ...args: GetActionDefinitionsMap<ActionsMap>[K]["actionArguments"]) => Promise<import("./action.js").ActionResponse<Awaited<ReturnType<ActionsMap[K]>>, Parameters<ActionsMap[K]>>>;
     readonly addListener: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], options?: ListenerOptions) => void;
     /** @alias addListener */
     readonly on: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], options?: ListenerOptions) => void;
@@ -35,6 +38,7 @@ export declare function createActionBus<ActionsMap extends BaseActionsMap>(initi
     readonly un: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], context?: object | null, tag?: string | null) => boolean;
     /** @alias removeListener */
     readonly unsubscribe: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], context?: object | null, tag?: string | null) => boolean;
+    readonly updateListenerOptions: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], context?: object | null, nextOptions?: ListenerOptions) => boolean;
     readonly addErrorListener: (handler: ErrorListenerSignature<any[]>, listenerOptions?: ListenerOptions) => void;
     readonly removeErrorListener: (handler: ErrorListenerSignature<any[]>, context?: object | null, tag?: string | null) => boolean;
 }>;

package/dist/actionBus.js

@@ -1,17 +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.js";
+import { createEvent } from "./event.js";
+export function createActionBus(initialActions = {}, errorListener) {
     const actions = new Map();
-    const errorEvent = (0, event_1.createEvent)();
+    const errorEvent = createEvent();
     if (errorListener) {
         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" });
             });
@@ -24,6 +21,27 @@ function createActionBus(initialActions = {}, errorListener) {
     const get = (name) => {
         return actions.get(name);
     };
+    const has = (name) => {
+        return actions.has(name);
+    };
+    // Replace an action's function in place when it exists (preserving all of
+    // its listeners and the bus error-forwarding listener, which is attached to
+    // the action's error event, not the function); otherwise add it.
+    const replace = (name, action) => {
+        const existing = actions.get(name);
+        if (existing) {
+            existing.setAction(action);
+        }
+        else {
+            add(name, action);
+        }
+    };
+    // Named removeAction (not remove) because `remove` is an existing alias for
+    // removeListener. The removed action's listeners and its error-forwarding
+    // listener are dropped with it (they lived on the action's own events).
+    const removeAction = (name) => {
+        actions.delete(name);
+    };
     const invoke = (name, ...args) => {
         const action = get(name);
         if (!action) {
@@ -54,8 +72,18 @@ function createActionBus(initialActions = {}, errorListener) {
         }
         return action.removeListener(handler, context, tag);
     };
+    const updateListenerOptions = (name, handler, context, nextOptions) => {
+        const action = get(name);
+        if (!action) {
+            return false;
+        }
+        return action.updateListenerOptions(handler, context, nextOptions);
+    };
     const api = {
         add,
+        replace,
+        removeAction,
+        has,
         get,
         invoke,
         addListener: on,
@@ -75,6 +103,7 @@ function createActionBus(initialActions = {}, errorListener) {
         un: un,
         /** @alias removeListener */
         unsubscribe: un,
+        updateListenerOptions,
         addErrorListener: errorEvent.addListener,
         removeErrorListener: errorEvent.removeListener,
     };

package/dist/actionMap.d.ts

@@ -1,27 +1,29 @@
-import type { ActionResponse } from "./action";
-import type { BaseActionsMap } from "./actionBus";
-import type { ErrorListenerSignature, ErrorResponse, KeyOf } from "./lib/types";
+import type { ActionResponse } from "./action.js";
+import type { BaseActionsMap } from "./actionBus.js";
+import type { ErrorListenerSignature, ErrorResponse, KeyOf } from "./lib/types.js";
 export type { ActionResponse, BaseActionsMap, ErrorListenerSignature, ErrorResponse, };
 export declare function createActionMap<M extends BaseActionsMap>(actions: M, onAnyError?: ErrorListenerSignature<any[]> | ErrorListenerSignature<any[]>[]): { [key in KeyOf<M>]: {
     readonly invoke: (...args: Parameters<M[key]>) => Promise<ActionResponse<Awaited<ReturnType<M[key]>>, Parameters<M[key]>>>;
-    readonly addListener: (handler: import("./action").ListenerSignature<M[key]>, listenerOptions?: import("./event").ListenerOptions) => void;
-    readonly on: (handler: import("./action").ListenerSignature<M[key]>, listenerOptions?: import("./event").ListenerOptions) => void;
-    readonly subscribe: (handler: import("./action").ListenerSignature<M[key]>, listenerOptions?: import("./event").ListenerOptions) => void;
-    readonly listen: (handler: import("./action").ListenerSignature<M[key]>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly setAction: (nextAction: M[key]) => void;
+    readonly addListener: (handler: import("./action.js").ListenerSignature<M[key]>, listenerOptions?: import("./event.js").ListenerOptions) => void;
+    readonly on: (handler: import("./action.js").ListenerSignature<M[key]>, listenerOptions?: import("./event.js").ListenerOptions) => void;
+    readonly subscribe: (handler: import("./action.js").ListenerSignature<M[key]>, listenerOptions?: import("./event.js").ListenerOptions) => void;
+    readonly listen: (handler: import("./action.js").ListenerSignature<M[key]>, listenerOptions?: import("./event.js").ListenerOptions) => void;
     readonly removeAllListeners: (tag?: string) => void;
-    readonly removeListener: (handler: import("./action").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
-    readonly un: (handler: import("./action").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
-    readonly off: (handler: import("./action").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
-    readonly remove: (handler: import("./action").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
-    readonly unsubscribe: (handler: import("./action").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
-    readonly promise: (options?: import("./event").ListenerOptions) => Promise<[arg: ActionResponse<Awaited<ReturnType<M[key]>>, Parameters<M[key]>>]>;
-    readonly addErrorListener: (handler: ErrorListenerSignature<Parameters<M[key]>>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly removeListener: (handler: import("./action.js").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly un: (handler: import("./action.js").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly off: (handler: import("./action.js").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly remove: (handler: import("./action.js").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly unsubscribe: (handler: import("./action.js").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly updateListenerOptions: (handler: import("./action.js").ListenerSignature<M[key]>, context?: object | null, nextOptions?: import("./event.js").ListenerOptions) => boolean;
+    readonly promise: (options?: import("./event.js").ListenerOptions) => Promise<[arg: ActionResponse<Awaited<ReturnType<M[key]>>, Parameters<M[key]>>]>;
+    readonly addErrorListener: (handler: ErrorListenerSignature<Parameters<M[key]>>, listenerOptions?: import("./event.js").ListenerOptions) => void;
     readonly removeAllErrorListeners: (tag?: string) => void;
     readonly removeErrorListener: (handler: ErrorListenerSignature<Parameters<M[key]>>, context?: object | null, tag?: string | null) => boolean;
-    readonly errorPromise: (options?: import("./event").ListenerOptions) => Promise<[errorResponse: ErrorResponse<Parameters<M[key]>>]>;
-    readonly addBeforeActionListener: (handler: import("./action").BeforeActionSignature<M[key]>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly errorPromise: (options?: import("./event.js").ListenerOptions) => Promise<[errorResponse: ErrorResponse<Parameters<M[key]>>]>;
+    readonly addBeforeActionListener: (handler: import("./action.js").BeforeActionSignature<M[key]>, listenerOptions?: import("./event.js").ListenerOptions) => void;
     readonly removeAllBeforeActionListeners: (tag?: string) => void;
-    readonly removeBeforeActionListener: (handler: import("./action").BeforeActionSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
-    readonly beforeActionPromise: (options?: import("./event").ListenerOptions) => Promise<Parameters<M[key]>>;
-    __type: import("./action").ActionDefinitionHelper<M[key]>;
+    readonly removeBeforeActionListener: (handler: import("./action.js").BeforeActionSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly beforeActionPromise: (options?: import("./event.js").ListenerOptions) => Promise<Parameters<M[key]>>;
+    __type: import("./action.js").ActionDefinitionHelper<M[key]>;
 }; };

package/dist/actionMap.js

@@ -1,26 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createActionMap = createActionMap;
-const action_1 = require("./action");
-function createActionMap(actions, onAnyError) {
+import { createAction } from "./action.js";
+import { ActionMapSetErrorListeners } from "./lib/actionMapInternal.js";
+export function createActionMap(actions, onAnyError) {
+    let currentOnAnyError = onAnyError;
     const errorListenersMap = {};
     for (const key in actions) {
         errorListenersMap[key] = (errorResponse) => {
-            if (Array.isArray(onAnyError)) {
-                for (const listener of onAnyError) {
+            const handlers = currentOnAnyError;
+            if (Array.isArray(handlers)) {
+                for (const listener of handlers) {
                     listener === null || listener === void 0 ? void 0 : listener(Object.assign({ name: key }, errorResponse));
                 }
             }
             else {
-                onAnyError === null || onAnyError === void 0 ? void 0 : onAnyError(Object.assign({ name: key }, errorResponse));
+                handlers === null || handlers === void 0 ? void 0 : handlers(Object.assign({ name: key }, errorResponse));
             }
         };
     }
     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;
     }
+    map[ActionMapSetErrorListeners] = (next) => {
+        currentOnAnyError = next;
+    };
     return map;
 }

package/dist/event.d.ts

@@ -1,4 +1,4 @@
-import type { ApiType, BaseHandler, ErrorListenerSignature } from "./lib/types";
+import type { ApiType, BaseHandler, ErrorListenerSignature } from "./lib/types.js";
 type Unarray<T> = T extends (infer U)[] ? U : T;
 interface BaseOptions {
     /**
@@ -93,6 +93,7 @@ export declare function createEvent<ListenerSignature extends BaseHandler>(event
     /** @alias addListener */
     readonly subscribe: (handler: ListenerSignature, listenerOptions?: ListenerOptions) => void;
     readonly removeListener: (handler: ListenerSignature, context?: object | null, tag?: string | null) => boolean;
+    readonly updateListenerOptions: (handler: ListenerSignature, context?: object | null, nextOptions?: ListenerOptions) => boolean;
     /** @alias removeListener */
     readonly un: (handler: ListenerSignature, context?: object | null, tag?: string | null) => boolean;
     /** @alias removeListener */
@@ -114,7 +115,7 @@ export declare function createEvent<ListenerSignature extends BaseHandler>(event
     readonly removeErrorListener: (handler: ErrorListenerSignature<Parameters<ListenerSignature>>, context?: object | null) => boolean;
     readonly suspend: (withQueue?: boolean) => void;
     readonly resume: () => void;
-    readonly setOptions: (eventOptions: Pick<EventOptions<ListenerSignature>, "async" | "limit" | "autoTrigger">) => void;
+    readonly setOptions: (eventOptions: Partial<EventOptions<ListenerSignature>>) => void;
     readonly reset: () => void;
     readonly isSuspended: () => boolean;
     readonly isQueued: () => boolean;