@kuindji/reactive 1.0.0

package/dist/react/ErrorBoundary.d.ts

@@ -0,0 +1,10 @@
+import type { ErrorListenerSignature, ErrorResponse } from "../lib/types";
+export type ErrorBoundaryProps = {
+    children: React.ReactNode;
+    listener?: ErrorListenerSignature<any>;
+};
+export type { ErrorListenerSignature, ErrorResponse };
+export declare const ErrorBoundaryContext: import("react").Context<ErrorListenerSignature<any> | null>;
+declare function ErrorBoundary({ children, listener }: ErrorBoundaryProps): import("react/jsx-runtime").JSX.Element;
+export default ErrorBoundary;
+export { ErrorBoundary };

package/dist/react/ErrorBoundary.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorBoundaryContext = void 0;
+exports.ErrorBoundary = ErrorBoundary;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+exports.ErrorBoundaryContext = (0, react_1.createContext)(null);
+function ErrorBoundary({ children, listener }) {
+    const boundaryErrorListener = (0, react_1.useContext)(exports.ErrorBoundaryContext);
+    const thisRef = (0, react_1.useRef)(listener);
+    const outerRef = (0, react_1.useRef)(boundaryErrorListener);
+    const thisErrorListener = (0, react_1.useCallback)((errorResponse) => {
+        if (thisRef.current) {
+            thisRef.current(errorResponse);
+        }
+        else if (outerRef.current) {
+            outerRef.current(errorResponse);
+        }
+        else {
+            throw errorResponse.error;
+        }
+    }, []);
+    return ((0, jsx_runtime_1.jsx)(exports.ErrorBoundaryContext.Provider, { value: thisErrorListener, children: children }));
+}
+exports.default = ErrorBoundary;

package/dist/react/useAction.d.ts

@@ -0,0 +1,21 @@
+import type { ActionResponse, ListenerSignature } from "../action";
+import type { BaseHandler, ErrorListenerSignature, ErrorResponse } from "../lib/types";
+export type { ActionResponse, BaseHandler, ErrorListenerSignature, ErrorResponse, ListenerSignature, };
+export declare function useAction<ActionSignature extends BaseHandler, Listener extends ListenerSignature<ActionSignature>, ErrorListener extends ErrorListenerSignature<Parameters<ActionSignature>>>(actionSignature: ActionSignature, listener?: Listener | null, errorListener?: ErrorListener | null): import("../lib/types").ApiType<import("../action").ActionDefinitionHelper<ActionSignature>, {
+    readonly invoke: (...args: Parameters<ActionSignature>) => Promise<ActionResponse<Awaited<ReturnType<ActionSignature>>, Parameters<ActionSignature>>>;
+    readonly addListener: (handler: ListenerSignature<ActionSignature>, listenerOptions?: import("..").ListenerOptions) => void;
+    readonly on: (handler: ListenerSignature<ActionSignature>, listenerOptions?: import("..").ListenerOptions) => void;
+    readonly subscribe: (handler: ListenerSignature<ActionSignature>, listenerOptions?: import("..").ListenerOptions) => void;
+    readonly listen: (handler: ListenerSignature<ActionSignature>, listenerOptions?: import("..").ListenerOptions) => void;
+    readonly removeAllListeners: (tag?: string) => void;
+    readonly removeListener: (handler: ListenerSignature<ActionSignature>, context?: object | null, tag?: string | null) => boolean;
+    readonly un: (handler: ListenerSignature<ActionSignature>, context?: object | null, tag?: string | null) => boolean;
+    readonly off: (handler: ListenerSignature<ActionSignature>, context?: object | null, tag?: string | null) => boolean;
+    readonly remove: (handler: ListenerSignature<ActionSignature>, context?: object | null, tag?: string | null) => boolean;
+    readonly unsubscribe: (handler: ListenerSignature<ActionSignature>, context?: object | null, tag?: string | null) => boolean;
+    readonly promise: (options?: import("..").ListenerOptions) => Promise<[arg: ActionResponse<Awaited<ReturnType<ActionSignature>>, Parameters<ActionSignature>>]>;
+    readonly addErrorListener: (handler: ErrorListenerSignature<Parameters<ActionSignature>>, listenerOptions?: import("..").ListenerOptions) => void;
+    readonly removeAllErrorListeners: (tag?: string) => void;
+    readonly removeErrorListener: (handler: ErrorListenerSignature<Parameters<ActionSignature>>, context?: object | null, tag?: string | null) => boolean;
+    readonly errorPromise: (options?: import("..").ListenerOptions) => Promise<[errorResponse: ErrorResponse<Parameters<ActionSignature>>]>;
+}>;

package/dist/react/useAction.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAction = useAction;
+const react_1 = require("react");
+const action_1 = require("../action");
+const ErrorBoundary_1 = require("./ErrorBoundary");
+function useAction(actionSignature, listener, errorListener) {
+    const boundaryErrorListener = (0, react_1.useContext)(ErrorBoundary_1.ErrorBoundaryContext);
+    const updateRef = (0, react_1.useRef)(0);
+    const listenerRef = (0, react_1.useRef)(listener);
+    const errorListenerRef = (0, react_1.useRef)(errorListener);
+    const boundaryErrorListenerRef = (0, react_1.useRef)(boundaryErrorListener);
+    const action = (0, react_1.useMemo)(() => {
+        const action = (0, action_1.createAction)(actionSignature);
+        if (listenerRef.current) {
+            action.addListener(listenerRef.current);
+        }
+        if (errorListenerRef.current) {
+            action.addErrorListener(errorListenerRef.current);
+        }
+        if (boundaryErrorListenerRef.current) {
+            action.addErrorListener(boundaryErrorListenerRef.current);
+        }
+        return action;
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (updateRef.current > 0) {
+            throw new Error("Action cannot be updated");
+        }
+        updateRef.current++;
+    }, [actionSignature]);
+    (0, react_1.useEffect)(() => {
+        if (listenerRef.current !== listener) {
+            if (listenerRef.current) {
+                action.removeListener(listenerRef.current);
+            }
+            listenerRef.current = listener !== null && listener !== void 0 ? listener : null;
+            if (listener) {
+                action.addListener(listener);
+            }
+        }
+    }, [listener]);
+    (0, react_1.useEffect)(() => {
+        if (errorListenerRef.current !== errorListener) {
+            if (errorListenerRef.current) {
+                action.removeErrorListener(errorListenerRef.current);
+            }
+            errorListenerRef.current = errorListener !== null && errorListener !== void 0 ? errorListener : null;
+            if (errorListener) {
+                action.addErrorListener(errorListener);
+            }
+        }
+    }, [errorListener]);
+    (0, react_1.useEffect)(() => {
+        if (boundaryErrorListenerRef.current !== boundaryErrorListener) {
+            if (boundaryErrorListenerRef.current) {
+                action.removeErrorListener(boundaryErrorListenerRef.current);
+            }
+            boundaryErrorListenerRef.current = boundaryErrorListener !== null && boundaryErrorListener !== void 0 ? boundaryErrorListener : null;
+            if (boundaryErrorListener) {
+                action.addErrorListener(boundaryErrorListener);
+            }
+        }
+    }, [boundaryErrorListener]);
+    return action;
+}

package/dist/react/useActionBus.d.ts

@@ -0,0 +1,38 @@
+import type { ActionResponse, ListenerSignature } from "../action";
+import type { BaseActionsMap } from "../actionBus";
+import type { ErrorListenerSignature, ErrorResponse } from "../lib/types";
+export type { ActionResponse, BaseActionsMap, ErrorListenerSignature, ErrorResponse, ListenerSignature, };
+export declare function useActionBus<ActionsMap extends BaseActionsMap = BaseActionsMap>(initialActions?: ActionsMap, errorListener?: ErrorListenerSignature<any[]>): import("../lib/types").ApiType<import("../actionBus").ActionBusDefinitionHelper<ActionsMap>, {
+    readonly add: (name: import("../lib/types").MapKey, action: import("../lib/types").BaseHandler) => void;
+    readonly get: <K extends import("../lib/types").KeyOf<{ [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }>>(name: K) => { [key_1 in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key_1]] extends [never] ? never : import("../lib/types").ApiType<import("../action").ActionDefinitionHelper<ActionsMap[key_1]>, {
+        readonly invoke: (...args: Parameters<ActionsMap[key_1]>) => Promise<ActionResponse<Awaited<ReturnType<ActionsMap[key_1]>>, Parameters<ActionsMap[key_1]>>>;
+        readonly addListener: (handler: ListenerSignature<ActionsMap[key_1]>, listenerOptions?: import("..").ListenerOptions) => void;
+        readonly on: (handler: ListenerSignature<ActionsMap[key_1]>, listenerOptions?: import("..").ListenerOptions) => void;
+        readonly subscribe: (handler: ListenerSignature<ActionsMap[key_1]>, listenerOptions?: import("..").ListenerOptions) => void;
+        readonly listen: (handler: ListenerSignature<ActionsMap[key_1]>, listenerOptions?: import("..").ListenerOptions) => void;
+        readonly removeAllListeners: (tag?: string) => void;
+        readonly removeListener: (handler: ListenerSignature<ActionsMap[key_1]>, context?: object | null, tag?: string | null) => boolean;
+        readonly un: (handler: ListenerSignature<ActionsMap[key_1]>, context?: object | null, tag?: string | null) => boolean;
+        readonly off: (handler: ListenerSignature<ActionsMap[key_1]>, context?: object | null, tag?: string | null) => boolean;
+        readonly remove: (handler: ListenerSignature<ActionsMap[key_1]>, context?: object | null, tag?: string | null) => boolean;
+        readonly unsubscribe: (handler: ListenerSignature<ActionsMap[key_1]>, context?: object | null, tag?: string | null) => boolean;
+        readonly promise: (options?: import("..").ListenerOptions) => Promise<[arg: ActionResponse<Awaited<ReturnType<ActionsMap[key_1]>>, Parameters<ActionsMap[key_1]>>]>;
+        readonly addErrorListener: (handler: ErrorListenerSignature<Parameters<ActionsMap[key_1]>>, listenerOptions?: import("..").ListenerOptions) => void;
+        readonly removeAllErrorListeners: (tag?: string) => void;
+        readonly removeErrorListener: (handler: ErrorListenerSignature<Parameters<ActionsMap[key_1]>>, context?: object | null, tag?: string | null) => boolean;
+        readonly errorPromise: (options?: import("..").ListenerOptions) => Promise<[errorResponse: ErrorResponse<Parameters<ActionsMap[key_1]>>]>;
+    }>; }[K];
+    readonly invoke: <K extends import("../lib/types").KeyOf<{ [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }>>(name: K, ...args: { [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }[K]["actionArguments"]) => Promise<ActionResponse<Awaited<ReturnType<ActionsMap[K]>>, Parameters<ActionsMap[K]>>>;
+    readonly addListener: <K extends import("../lib/types").KeyOf<{ [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }>>(name: K, handler: { [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }[K]["listenerSignature"], options?: import("..").ListenerOptions) => void;
+    readonly on: <K extends import("../lib/types").KeyOf<{ [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }>>(name: K, handler: { [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }[K]["listenerSignature"], options?: import("..").ListenerOptions) => void;
+    readonly subscribe: <K extends import("../lib/types").KeyOf<{ [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }>>(name: K, handler: { [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }[K]["listenerSignature"], options?: import("..").ListenerOptions) => void;
+    readonly listen: <K extends import("../lib/types").KeyOf<{ [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }>>(name: K, handler: { [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }[K]["listenerSignature"], options?: import("..").ListenerOptions) => void;
+    readonly once: <K extends import("../lib/types").KeyOf<{ [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }>>(name: K, handler: { [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }[K]["listenerSignature"], options?: import("..").ListenerOptions) => void;
+    readonly removeListener: <K extends import("../lib/types").KeyOf<{ [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }>>(name: K, handler: { [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }[K]["listenerSignature"], context?: object | null, tag?: string | null) => boolean;
+    readonly off: <K extends import("../lib/types").KeyOf<{ [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }>>(name: K, handler: { [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }[K]["listenerSignature"], context?: object | null, tag?: string | null) => boolean;
+    readonly remove: <K extends import("../lib/types").KeyOf<{ [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }>>(name: K, handler: { [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }[K]["listenerSignature"], context?: object | null, tag?: string | null) => boolean;
+    readonly un: <K extends import("../lib/types").KeyOf<{ [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }>>(name: K, handler: { [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }[K]["listenerSignature"], context?: object | null, tag?: string | null) => boolean;
+    readonly unsubscribe: <K extends import("../lib/types").KeyOf<{ [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }>>(name: K, handler: { [key in import("../lib/types").KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : import("../action").ActionDefinitionHelper<ActionsMap[key]>; }[K]["listenerSignature"], context?: object | null, tag?: string | null) => boolean;
+    readonly addErrorListener: (handler: ErrorListenerSignature<any[]>, listenerOptions?: import("..").ListenerOptions) => void;
+    readonly removeErrorListener: (handler: ErrorListenerSignature<any[]>, context?: object | null, tag?: string | null) => boolean;
+}>;

package/dist/react/useActionBus.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useActionBus = useActionBus;
+const react_1 = require("react");
+const actionBus_1 = require("../actionBus");
+const ErrorBoundary_1 = require("./ErrorBoundary");
+function useActionBus(initialActions, errorListener) {
+    const boundaryErrorListener = (0, react_1.useContext)(ErrorBoundary_1.ErrorBoundaryContext);
+    const errorListenerRef = (0, react_1.useRef)(errorListener);
+    const boundaryErrorListenerRef = (0, react_1.useRef)(boundaryErrorListener);
+    const actionBus = (0, react_1.useMemo)(() => {
+        const actionBus = (0, actionBus_1.createActionBus)(initialActions);
+        if (errorListener) {
+            actionBus.addErrorListener(errorListener);
+        }
+        if (boundaryErrorListener) {
+            actionBus.addErrorListener(boundaryErrorListener);
+        }
+        return actionBus;
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (errorListenerRef.current !== errorListener) {
+            if (errorListenerRef.current) {
+                actionBus.removeErrorListener(errorListenerRef.current);
+            }
+            errorListenerRef.current = errorListener !== null && errorListener !== void 0 ? errorListener : null;
+            if (errorListener) {
+                actionBus.addErrorListener(errorListener);
+            }
+        }
+    }, [errorListener]);
+    (0, react_1.useEffect)(() => {
+        if (boundaryErrorListenerRef.current !== boundaryErrorListener) {
+            if (boundaryErrorListenerRef.current) {
+                actionBus.removeErrorListener(boundaryErrorListenerRef.current);
+            }
+            boundaryErrorListenerRef.current = boundaryErrorListener !== null && boundaryErrorListener !== void 0 ? boundaryErrorListener : null;
+            if (boundaryErrorListener) {
+                actionBus.addErrorListener(boundaryErrorListener);
+            }
+        }
+    }, [boundaryErrorListener]);
+    return actionBus;
+}

package/dist/react/useActionMap.d.ts

@@ -0,0 +1,23 @@
+import type { ActionResponse, ListenerSignature } from "../action";
+import type { BaseActionsMap } from "../actionBus";
+import type { ErrorListenerSignature, ErrorResponse, Simplify } from "../lib/types";
+export type { ActionResponse, BaseActionsMap, ErrorListenerSignature, ErrorResponse, ListenerSignature, };
+export declare function useActionMap<M extends BaseActionsMap>(actions: M, errorListener?: ErrorListenerSignature<any[]>): Simplify<{ [key in import("../lib/types").KeyOf<M>]: {
+    readonly invoke: (...args: Parameters<M[key]>) => Promise<ActionResponse<Awaited<ReturnType<M[key]>>, Parameters<M[key]>>>;
+    readonly addListener: (handler: ListenerSignature<M[key]>, listenerOptions?: import("..").ListenerOptions) => void;
+    readonly on: (handler: ListenerSignature<M[key]>, listenerOptions?: import("..").ListenerOptions) => void;
+    readonly subscribe: (handler: ListenerSignature<M[key]>, listenerOptions?: import("..").ListenerOptions) => void;
+    readonly listen: (handler: ListenerSignature<M[key]>, listenerOptions?: import("..").ListenerOptions) => void;
+    readonly removeAllListeners: (tag?: string) => void;
+    readonly removeListener: (handler: ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly un: (handler: ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly off: (handler: ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly remove: (handler: ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly unsubscribe: (handler: ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly promise: (options?: import("..").ListenerOptions) => Promise<[arg: ActionResponse<Awaited<ReturnType<M[key]>>, Parameters<M[key]>>]>;
+    readonly addErrorListener: (handler: ErrorListenerSignature<Parameters<M[key]>>, listenerOptions?: import("..").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("..").ListenerOptions) => Promise<[errorResponse: ErrorResponse<Parameters<M[key]>>]>;
+    __type: import("../action").ActionDefinitionHelper<M[key]>;
+}; }>;

package/dist/react/useActionMap.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useActionMap = useActionMap;
+const react_1 = require("react");
+const actionMap_1 = require("../actionMap");
+const ErrorBoundary_1 = require("./ErrorBoundary");
+function useActionMap(actions, errorListener) {
+    const boundaryErrorListener = (0, react_1.useContext)(ErrorBoundary_1.ErrorBoundaryContext);
+    const changeRef = (0, react_1.useRef)(0);
+    const actionMap = (0, react_1.useMemo)(() => {
+        const errorListeners = [
+            ...(errorListener ? [errorListener] : []),
+            ...(boundaryErrorListener ? [boundaryErrorListener] : []),
+        ].filter(l => l !== undefined);
+        const actionMap = (0, actionMap_1.createActionMap)(actions, errorListeners);
+        return actionMap;
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (changeRef.current > 0) {
+            throw new Error("useActionMap() does not support changing actions or errorListener");
+        }
+        changeRef.current++;
+    }, [actions, errorListener, boundaryErrorListener]);
+    return actionMap;
+}

package/dist/react/useEvent.d.ts

@@ -0,0 +1,47 @@
+import { type EventOptions } from "../event";
+import type { BaseHandler, ErrorListenerSignature, ErrorResponse } from "../lib/types";
+export type { BaseHandler, ErrorListenerSignature, ErrorResponse, EventOptions, };
+export declare function useEvent<Listener extends BaseHandler = BaseHandler, ErrorListener extends ErrorListenerSignature<Parameters<Listener>> = ErrorListenerSignature<Parameters<Listener>>>(eventOptions?: EventOptions<Listener>, listener?: Listener | null, errorListener?: ErrorListener | null): import("../lib/types").ApiType<import("../event").EventDefinitionHelper<Listener>, {
+    readonly addListener: (handler: Listener, listenerOptions?: import("../event").ListenerOptions) => void;
+    readonly on: (handler: Listener, listenerOptions?: import("../event").ListenerOptions) => void;
+    readonly listen: (handler: Listener, listenerOptions?: import("../event").ListenerOptions) => void;
+    readonly subscribe: (handler: Listener, listenerOptions?: import("../event").ListenerOptions) => void;
+    readonly removeListener: (handler: Listener, context?: object | null, tag?: string | null) => boolean;
+    readonly un: (handler: Listener, context?: object | null, tag?: string | null) => boolean;
+    readonly off: (handler: Listener, context?: object | null, tag?: string | null) => boolean;
+    readonly remove: (handler: Listener, context?: object | null, tag?: string | null) => boolean;
+    readonly unsubscribe: (handler: Listener, context?: object | null, tag?: string | null) => boolean;
+    readonly trigger: (...args: Parameters<Listener>) => void;
+    readonly emit: (...args: Parameters<Listener>) => void;
+    readonly dispatch: (...args: Parameters<Listener>) => void;
+    readonly hasListener: (handler?: Listener | null | undefined, context?: object | null, tag?: string | null) => boolean;
+    readonly has: (handler?: Listener | null | undefined, context?: object | null, tag?: string | null) => boolean;
+    readonly removeAllListeners: (tag?: string) => void;
+    readonly addErrorListener: (handler: ErrorListenerSignature<Parameters<Listener>>, context?: object | null) => void;
+    readonly removeErrorListener: (handler: ErrorListenerSignature<Parameters<Listener>>, context?: object | null) => boolean;
+    readonly suspend: (withQueue?: boolean) => void;
+    readonly resume: () => void;
+    readonly setOptions: (eventOptions: Pick<EventOptions<Listener>, "async" | "limit" | "autoTrigger">) => void;
+    readonly reset: () => void;
+    readonly isSuspended: () => boolean;
+    readonly isQueued: () => boolean;
+    readonly withTags: <T extends (...args: any[]) => any>(tags: string[], callback: T) => ReturnType<T>;
+    readonly promise: (options?: import("../event").ListenerOptions) => Promise<Parameters<Listener>>;
+    readonly first: (...args: Parameters<Listener>) => ReturnType<Listener> | undefined;
+    readonly resolveFirst: (...args: Parameters<Listener>) => Promise<Awaited<ReturnType<Listener>> | undefined>;
+    readonly all: (...args: Parameters<Listener>) => ReturnType<Listener>[];
+    readonly resolveAll: (...args: Parameters<Listener>) => Promise<Awaited<ReturnType<Listener>>[]>;
+    readonly last: (...args: Parameters<Listener>) => ReturnType<Listener> | undefined;
+    readonly resolveLast: (...args: Parameters<Listener>) => Promise<Awaited<ReturnType<Listener>> | undefined>;
+    readonly merge: (...args: Parameters<Listener>) => ReturnType<Listener> | undefined;
+    readonly resolveMerge: (...args: Parameters<Listener>) => Promise<Awaited<ReturnType<Listener>> | undefined>;
+    readonly concat: (...args: Parameters<Listener>) => (ReturnType<Listener> extends infer T ? T extends ReturnType<Listener> ? T extends (infer U)[] ? U : T : never : never)[];
+    readonly resolveConcat: (...args: Parameters<Listener>) => Promise<(Awaited<ReturnType<Listener>> extends infer T ? T extends Awaited<ReturnType<Listener>> ? T extends (infer U)[] ? U : T : never : never)[]>;
+    readonly firstNonEmpty: (...args: Parameters<Listener>) => ReturnType<Listener> | undefined;
+    readonly resolveFirstNonEmpty: (...args: Parameters<Listener>) => Promise<Awaited<ReturnType<Listener>> | undefined>;
+    readonly untilTrue: (...args: Parameters<Listener>) => void;
+    readonly untilFalse: (...args: Parameters<Listener>) => void;
+    readonly pipe: (...args: Parameters<Listener>) => ReturnType<Listener> | undefined;
+    readonly resolvePipe: (...args: Parameters<Listener>) => Promise<Awaited<ReturnType<Listener>> | undefined>;
+    readonly raw: (...args: Parameters<Listener>) => (ReturnType<Listener> extends infer T ? T extends ReturnType<Listener> ? T extends (infer U)[] ? U : T : never : never)[];
+}>;

package/dist/react/useEvent.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEvent = useEvent;
+const react_1 = require("react");
+const event_1 = require("../event");
+const ErrorBoundary_1 = require("./ErrorBoundary");
+function useEvent(eventOptions = {}, listener, errorListener) {
+    const boundaryErrorListener = (0, react_1.useContext)(ErrorBoundary_1.ErrorBoundaryContext);
+    const updateRef = (0, react_1.useRef)(0);
+    const listenerRef = (0, react_1.useRef)(listener);
+    const errorListenerRef = (0, react_1.useRef)(errorListener);
+    const boundaryErrorListenerRef = (0, react_1.useRef)(boundaryErrorListener);
+    const event = (0, react_1.useMemo)(() => {
+        const event = (0, event_1.createEvent)(eventOptions);
+        if (listenerRef.current) {
+            event.addListener(listenerRef.current);
+        }
+        if (errorListenerRef.current) {
+            event.addErrorListener(errorListenerRef.current);
+        }
+        if (boundaryErrorListenerRef.current) {
+            event.addErrorListener(boundaryErrorListenerRef.current);
+        }
+        return event;
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (updateRef.current > 0) {
+            throw new Error("Event cannot be updated");
+        }
+        updateRef.current++;
+    }, [event]);
+    (0, react_1.useEffect)(() => {
+        if (listenerRef.current !== listener) {
+            if (listenerRef.current) {
+                event.removeListener(listenerRef.current);
+            }
+            listenerRef.current = listener !== null && listener !== void 0 ? listener : null;
+            if (listener) {
+                event.addListener(listener);
+            }
+        }
+    }, [listener]);
+    (0, react_1.useEffect)(() => {
+        if (errorListenerRef.current !== errorListener) {
+            if (errorListenerRef.current) {
+                event.removeErrorListener(errorListenerRef.current);
+            }
+            errorListenerRef.current = errorListener !== null && errorListener !== void 0 ? errorListener : null;
+            if (errorListener) {
+                event.addErrorListener(errorListener);
+            }
+        }
+    }, [errorListener]);
+    (0, react_1.useEffect)(() => {
+        if (boundaryErrorListenerRef.current !== boundaryErrorListener) {
+            if (boundaryErrorListenerRef.current) {
+                event.removeErrorListener(boundaryErrorListenerRef.current);
+            }
+            boundaryErrorListenerRef.current = boundaryErrorListener !== null && boundaryErrorListener !== void 0 ? boundaryErrorListener : null;
+            if (boundaryErrorListener) {
+                event.addErrorListener(boundaryErrorListener);
+            }
+        }
+    }, [boundaryErrorListener]);
+    return event;
+}

package/dist/react/useEventBus.d.ts

@@ -0,0 +1,117 @@
+import { BaseEventMap, DefaultEventMap, EventBusOptions } from "../eventBus";
+import type { BaseHandler, ErrorListenerSignature, ErrorResponse } from "../lib/types";
+export type { BaseEventMap, BaseHandler, ErrorListenerSignature, ErrorResponse, EventBusOptions, };
+export declare function useEventBus<EventsMap extends BaseEventMap = DefaultEventMap>(eventBusOptions?: EventBusOptions<EventsMap>, allEventsListener?: BaseHandler, errorListener?: ErrorListenerSignature<any[]>): import("../lib/types").ApiType<import("../eventBus").EventBusDefinitionHelper<EventsMap>, {
+    readonly addListener: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, H extends import("../eventBus").GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, options?: import("..").ListenerOptions) => void;
+    readonly on: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, H extends import("../eventBus").GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, options?: import("..").ListenerOptions) => void;
+    readonly listen: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, H extends import("../eventBus").GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, options?: import("..").ListenerOptions) => void;
+    readonly subscribe: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, H extends import("../eventBus").GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, options?: import("..").ListenerOptions) => void;
+    readonly once: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, H extends import("../eventBus").GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, options?: import("..").ListenerOptions) => void;
+    readonly promise: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>>(name: K, options?: import("..").ListenerOptions) => Promise<Parameters<EventsMap[K]>>;
+    readonly removeListener: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, H extends import("../eventBus").GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly un: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, H extends import("../eventBus").GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly off: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, H extends import("../eventBus").GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly remove: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, H extends import("../eventBus").GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly unsubscribe: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, H extends import("../eventBus").GetEventsMap<EventsMap>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
+    readonly trigger: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => void;
+    readonly emit: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => void;
+    readonly dispatch: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => void;
+    readonly get: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>>(name: K) => { [key in import("../lib/types").KeyOf<EventsMap>]: import("../lib/types").ApiType<import("..").EventDefinitionHelper<EventsMap[key]>, {
+        readonly addListener: (handler: EventsMap[key], listenerOptions?: import("..").ListenerOptions) => void;
+        readonly on: (handler: EventsMap[key], listenerOptions?: import("..").ListenerOptions) => void;
+        readonly listen: (handler: EventsMap[key], listenerOptions?: import("..").ListenerOptions) => void;
+        readonly subscribe: (handler: EventsMap[key], listenerOptions?: import("..").ListenerOptions) => void;
+        readonly removeListener: (handler: EventsMap[key], context?: object | null, tag?: string | null) => boolean;
+        readonly un: (handler: EventsMap[key], context?: object | null, tag?: string | null) => boolean;
+        readonly off: (handler: EventsMap[key], context?: object | null, tag?: string | null) => boolean;
+        readonly remove: (handler: EventsMap[key], context?: object | null, tag?: string | null) => boolean;
+        readonly unsubscribe: (handler: EventsMap[key], context?: object | null, tag?: string | null) => boolean;
+        readonly trigger: (...args: Parameters<EventsMap[key]>) => void;
+        readonly emit: (...args: Parameters<EventsMap[key]>) => void;
+        readonly dispatch: (...args: Parameters<EventsMap[key]>) => void;
+        readonly hasListener: (handler?: EventsMap[key] | null | undefined, context?: object | null, tag?: string | null) => boolean;
+        readonly has: (handler?: EventsMap[key] | null | undefined, context?: object | null, tag?: string | null) => boolean;
+        readonly removeAllListeners: (tag?: string) => void;
+        readonly addErrorListener: (handler: ErrorListenerSignature<Parameters<EventsMap[key]>>, context?: object | null) => void;
+        readonly removeErrorListener: (handler: ErrorListenerSignature<Parameters<EventsMap[key]>>, context?: object | null) => boolean;
+        readonly suspend: (withQueue?: boolean) => void;
+        readonly resume: () => void;
+        readonly setOptions: (eventOptions: Pick<import("..").EventOptions<EventsMap[key]>, "async" | "limit" | "autoTrigger">) => void;
+        readonly reset: () => void;
+        readonly isSuspended: () => boolean;
+        readonly isQueued: () => boolean;
+        readonly withTags: <T extends (...args: any[]) => any>(tags: string[], callback: T) => ReturnType<T>;
+        readonly promise: (options?: import("..").ListenerOptions) => Promise<Parameters<EventsMap[key]>>;
+        readonly first: (...args: Parameters<EventsMap[key]>) => ReturnType<EventsMap[key]> | undefined;
+        readonly resolveFirst: (...args: Parameters<EventsMap[key]>) => Promise<Awaited<ReturnType<EventsMap[key]>> | undefined>;
+        readonly all: (...args: Parameters<EventsMap[key]>) => ReturnType<EventsMap[key]>[];
+        readonly resolveAll: (...args: Parameters<EventsMap[key]>) => Promise<Awaited<ReturnType<EventsMap[key]>>[]>;
+        readonly last: (...args: Parameters<EventsMap[key]>) => ReturnType<EventsMap[key]> | undefined;
+        readonly resolveLast: (...args: Parameters<EventsMap[key]>) => Promise<Awaited<ReturnType<EventsMap[key]>> | undefined>;
+        readonly merge: (...args: Parameters<EventsMap[key]>) => ReturnType<EventsMap[key]> | undefined;
+        readonly resolveMerge: (...args: Parameters<EventsMap[key]>) => Promise<Awaited<ReturnType<EventsMap[key]>> | undefined>;
+        readonly concat: (...args: Parameters<EventsMap[key]>) => (ReturnType<EventsMap[key]> extends infer T ? T extends ReturnType<EventsMap[key]> ? T extends (infer U)[] ? U : T : never : never)[];
+        readonly resolveConcat: (...args: Parameters<EventsMap[key]>) => Promise<(Awaited<ReturnType<EventsMap[key]>> extends infer T ? T extends Awaited<ReturnType<EventsMap[key]>> ? T extends (infer U)[] ? U : T : never : never)[]>;
+        readonly firstNonEmpty: (...args: Parameters<EventsMap[key]>) => ReturnType<EventsMap[key]> | undefined;
+        readonly resolveFirstNonEmpty: (...args: Parameters<EventsMap[key]>) => Promise<Awaited<ReturnType<EventsMap[key]>> | undefined>;
+        readonly untilTrue: (...args: Parameters<EventsMap[key]>) => void;
+        readonly untilFalse: (...args: Parameters<EventsMap[key]>) => void;
+        readonly pipe: (...args: Parameters<EventsMap[key]>) => ReturnType<EventsMap[key]> | undefined;
+        readonly resolvePipe: (...args: Parameters<EventsMap[key]>) => Promise<Awaited<ReturnType<EventsMap[key]>> | undefined>;
+        readonly raw: (...args: Parameters<EventsMap[key]>) => (ReturnType<EventsMap[key]> extends infer T ? T extends ReturnType<EventsMap[key]> ? T extends (infer U)[] ? U : T : never : never)[];
+    }>; }[K];
+    readonly add: (name: import("../lib/types").MapKey, options?: import("..").EventOptions<BaseHandler>) => void;
+    readonly first: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<EventsMap[K]> | undefined;
+    readonly resolveFirst: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>;
+    readonly all: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<EventsMap[K]>[];
+    readonly resolveAll: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => Promise<Awaited<ReturnType<EventsMap[K]>>[]>;
+    readonly last: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<EventsMap[K]> | undefined;
+    readonly resolveLast: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>;
+    readonly merge: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<EventsMap[K]> | undefined;
+    readonly resolveMerge: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>;
+    readonly concat: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => (ReturnType<EventsMap[K]> extends infer T ? T extends ReturnType<EventsMap[K]> ? T extends (infer U)[] ? U : T : never : never)[];
+    readonly resolveConcat: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => 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 import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<EventsMap[K]> | undefined;
+    readonly resolveFirstNonEmpty: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>;
+    readonly untilTrue: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => void>;
+    readonly untilFalse: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<(...args: Parameters<EventsMap[K]>) => void>;
+    readonly pipe: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => ReturnType<EventsMap[K]> | undefined;
+    readonly resolvePipe: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => Promise<Awaited<ReturnType<EventsMap[K]>> | undefined>;
+    readonly raw: <K extends import("../lib/types").KeyOf<import("../eventBus").GetEventsMap<EventsMap>>, A extends import("../eventBus").GetEventsMap<EventsMap>[K]["arguments"]>(name: K, ...args: A) => (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 intercept: (fn: (name: import("../lib/types").MapKey, args: any[], tags: string[] | null, returnType: import("../lib/types").TriggerReturnType | null) => boolean) => void;
+    readonly stopIntercepting: () => void;
+    readonly reset: () => void;
+    readonly suspendAll: (withQueue?: boolean) => void;
+    readonly resumeAll: () => void;
+    readonly relay: ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }: {
+        eventSource: {
+            on: (name: any, fn: (...args: any[]) => any, options?: import("..").ListenerOptions) => void;
+            addAllEventsListener: (fn: (name: any, args: any[]) => any, options?: import("..").ListenerOptions) => void;
+            un: (name: any, fn: (...args: any[]) => any, context?: object | null, tag?: string | null) => void;
+            removeAllEventsListener: (fn: (name: any, args: any[]) => any, context?: object | null, tag?: string | null) => void;
+        };
+        remoteEventName: import("../lib/types").MapKey;
+        localEventName?: any;
+        proxyType?: import("../lib/types").ProxyType;
+        localEventNamePrefix?: string | null;
+    }) => void;
+    readonly unrelay: ({ eventSource, remoteEventName, localEventName, proxyType, localEventNamePrefix, }: {
+        eventSource: {
+            on: (name: any, fn: (...args: any[]) => any, options?: import("..").ListenerOptions) => void;
+            addAllEventsListener: (fn: (name: any, args: any[]) => any, options?: import("..").ListenerOptions) => void;
+            un: (name: any, fn: (...args: any[]) => any, context?: object | null, tag?: string | null) => void;
+            removeAllEventsListener: (fn: (name: any, args: any[]) => any, context?: object | null, tag?: string | null) => void;
+        };
+        remoteEventName: import("../lib/types").MapKey;
+        localEventName?: any;
+        proxyType?: import("../lib/types").ProxyType;
+        localEventNamePrefix?: string | null;
+    }) => void;
+    readonly addEventSource: (eventSource: import("../eventBus").EventSource) => void;
+    readonly removeEventSource: (eventSource: import("../eventBus").EventSource | import("../lib/types").MapKey) => void;
+    readonly addAllEventsListener: (handler: (name: import("../lib/types").MapKey, args: any[], tags: string[] | null) => void, listenerOptions?: import("..").ListenerOptions) => void;
+    readonly removeAllEventsListener: (handler: (name: import("../lib/types").MapKey, args: any[], tags: string[] | null) => void, context?: object | null, tag?: string | null) => boolean;
+    readonly addErrorListener: (handler: ErrorListenerSignature<any[]>, listenerOptions?: import("..").ListenerOptions) => void;
+    readonly removeErrorListener: (handler: ErrorListenerSignature<any[]>, context?: object | null, tag?: string | null) => boolean;
+}>;

package/dist/react/useEventBus.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEventBus = useEventBus;
+const react_1 = require("react");
+const eventBus_1 = require("../eventBus");
+const ErrorBoundary_1 = require("./ErrorBoundary");
+function useEventBus(eventBusOptions, allEventsListener, errorListener) {
+    const boundaryErrorListener = (0, react_1.useContext)(ErrorBoundary_1.ErrorBoundaryContext);
+    const updateRef = (0, react_1.useRef)(0);
+    const errorListenerRef = (0, react_1.useRef)(errorListener);
+    const allEventsListenerRef = (0, react_1.useRef)(allEventsListener);
+    const boundaryErrorListenerRef = (0, react_1.useRef)(boundaryErrorListener);
+    const eventBus = (0, react_1.useMemo)(() => {
+        const eventBus = (0, eventBus_1.createEventBus)(eventBusOptions);
+        if (allEventsListener) {
+            eventBus.addAllEventsListener(allEventsListener);
+        }
+        if (errorListener) {
+            eventBus.addErrorListener(errorListener);
+        }
+        if (boundaryErrorListener) {
+            eventBus.addErrorListener(boundaryErrorListener);
+        }
+        return eventBus;
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (updateRef.current > 0) {
+            throw new Error("EventBus options can't be updated");
+        }
+        updateRef.current++;
+    }, [eventBusOptions]);
+    (0, react_1.useEffect)(() => {
+        if (allEventsListenerRef.current !== allEventsListener) {
+            if (allEventsListenerRef.current) {
+                eventBus.removeAllEventsListener(allEventsListenerRef.current);
+            }
+            allEventsListenerRef.current = allEventsListener;
+            if (allEventsListener) {
+                eventBus.addAllEventsListener(allEventsListener);
+            }
+        }
+    }, [allEventsListener]);
+    (0, react_1.useEffect)(() => {
+        if (errorListenerRef.current !== errorListener) {
+            if (errorListenerRef.current) {
+                eventBus.removeErrorListener(errorListenerRef.current);
+            }
+            errorListenerRef.current = errorListener;
+            if (errorListener) {
+                eventBus.addErrorListener(errorListener);
+            }
+        }
+    }, [errorListener]);
+    (0, react_1.useEffect)(() => {
+        if (boundaryErrorListenerRef.current !== boundaryErrorListener) {
+            if (boundaryErrorListenerRef.current) {
+                eventBus.removeErrorListener(boundaryErrorListenerRef.current);
+            }
+            boundaryErrorListenerRef.current = boundaryErrorListener;
+            if (boundaryErrorListener) {
+                eventBus.addErrorListener(boundaryErrorListener);
+            }
+        }
+    }, [boundaryErrorListener]);
+    return eventBus;
+}

package/dist/react/useListenToAction.d.ts

@@ -0,0 +1,3 @@
+import type { BaseAction } from "../action";
+export type { BaseAction };
+export declare function useListenToAction<TAction extends BaseAction, TListenerSignature extends TAction["__type"]["listenerSignature"] = TAction["__type"]["listenerSignature"], TErrorListenerSignature extends TAction["__type"]["errorListenerSignature"] = TAction["__type"]["errorListenerSignature"]>(action: TAction, listener: TListenerSignature | null, errorListener?: TErrorListenerSignature): void;