@kuindji/reactive 1.0.9 → 1.0.11

package/dist/react/useAction.d.ts

@@ -1,21 +1,5 @@
+import { createAction } from "../action";
 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>>]>;
-}>;
+export declare function useAction<ActionSignature extends BaseHandler, Listener extends ListenerSignature<ActionSignature>, ErrorListener extends ErrorListenerSignature<Parameters<ActionSignature>>>(actionSignature: ActionSignature, listener?: Listener | null, errorListener?: ErrorListener | null): ReturnType<typeof createAction<ActionSignature>>;

package/dist/react/useActionBus.d.ts

@@ -1,38 +1,6 @@
 import type { ActionResponse, ListenerSignature } from "../action";
 import type { BaseActionsMap } from "../actionBus";
+import { createActionBus } 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;
-}>;
+export declare function useActionBus<ActionsMap extends BaseActionsMap = BaseActionsMap>(initialActions?: ActionsMap, errorListener?: ErrorListenerSignature<any[]>): ReturnType<typeof createActionBus<ActionsMap>>;

package/dist/react/useActionMap.d.ts

@@ -1,23 +1,6 @@
 import type { ActionResponse, ListenerSignature } from "../action";
 import type { BaseActionsMap } from "../actionBus";
-import type { ErrorListenerSignature, ErrorResponse, Simplify } from "../lib/types";
+import { createActionMap } from "../actionMap";
+import type { ErrorListenerSignature, ErrorResponse } 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]>;
-}; }>;
+export declare function useActionMap<M extends BaseActionsMap>(actions: M, errorListener?: ErrorListenerSignature<any[]>): ReturnType<typeof createActionMap<M>>;

package/dist/react/useActionMap.js

@@ -20,6 +20,6 @@ function useActionMap(actions, errorListener) {
             throw new Error("useActionMap() does not support changing actions or errorListener");
         }
         changeRef.current++;
-    }, [actions, errorListener, boundaryErrorListener]);
+    }, [actions, errorListener !== null && errorListener !== void 0 ? errorListener : null, boundaryErrorListener !== null && boundaryErrorListener !== void 0 ? boundaryErrorListener : null]);
     return actionMap;
 }

package/dist/react/useEvent.d.ts

@@ -1,47 +1,4 @@
-import { type EventOptions } from "../event";
+import { createEvent, 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)[];
-}>;
+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): ReturnType<typeof createEvent<Listener>>;

package/dist/react/useEventBus.d.ts

@@ -1,118 +1,4 @@
-import { BaseEventMap, DefaultEventMap, EventBusOptions } from "../eventBus";
+import { BaseEventMap, createEventBus, 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 isIntercepting: () => boolean;
-    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;
-}>;
+export declare function useEventBus<EventsMap extends BaseEventMap = DefaultEventMap>(eventBusOptions?: EventBusOptions<EventsMap>, allEventsListener?: BaseHandler, errorListener?: ErrorListenerSignature<any[]>): ReturnType<typeof createEventBus<EventsMap>>;

package/dist/react/useEventBus.js

@@ -24,10 +24,12 @@ function useEventBus(eventBusOptions, allEventsListener, errorListener) {
         return eventBus;
     }, []);
     (0, react_1.useEffect)(() => {
-        if (updateRef.current > 0) {
-            throw new Error("EventBus options can't be updated");
+        if (eventBusOptions) {
+            if (updateRef.current > 0) {
+                throw new Error("EventBus options can't be updated");
+            }
+            updateRef.current++;
         }
-        updateRef.current++;
     }, [eventBusOptions]);
     (0, react_1.useEffect)(() => {
         if (allEventsListenerRef.current !== allEventsListener) {

package/dist/react/useStore.d.ts

@@ -1,3 +1,4 @@
+import { createStore } from "../store";
 import type { BasePropMap, BeforeChangeEventName, ChangeEventName, ErrorEventName, ResetEventName, StoreDefinitionHelper } from "../store";
 export type { BasePropMap, BeforeChangeEventName, ChangeEventName, ErrorEventName, ResetEventName, StoreDefinitionHelper, };
 export declare function useStore<PropMap extends BasePropMap, Store extends StoreDefinitionHelper<PropMap> = StoreDefinitionHelper<PropMap>, Config extends {
@@ -8,48 +9,4 @@ export declare function useStore<PropMap extends BasePropMap, Store extends Stor
     onChange?: Partial<Store["changeEvents"]>;
     pipes?: Partial<Store["pipeEvents"]>;
     control?: Partial<Store["controlEvents"]>;
-}>(initialData?: Partial<PropMap>, config?: Config): import("..").ApiType<StoreDefinitionHelper<PropMap>, {
-    readonly set: {
-        <K extends import("..").KeyOf<PropMap>>(key: K, value: PropMap[K] | undefined): void;
-        (key: Partial<PropMap>): void;
-    };
-    readonly get: <K extends import("..").KeyOf<PropMap> | import("..").KeyOf<PropMap>[]>(key: K) => K extends import("..").KeyOf<PropMap> ? PropMap[K] : K extends import("..").KeyOf<PropMap>[] ? { [AK in K[number]]: PropMap[AK]; } : never;
-    readonly getData: () => PropMap;
-    readonly batch: (fn: () => void) => void;
-    readonly asyncSet: {
-        <K extends import("..").KeyOf<PropMap>>(key: K, value: PropMap[K] | undefined): void;
-        (key: Partial<PropMap>): void;
-    };
-    readonly isEmpty: () => boolean;
-    readonly reset: () => void;
-    readonly onChange: <K extends import("..").KeyOf<import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1] | undefined, previousValue?: PropMap[K_1] | undefined) => void; }>>, H extends import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1] | undefined, previousValue?: PropMap[K_1] | undefined) => void; }>[K]["signature"]>(name: K, handler: H, options?: import("..").ListenerOptions) => void;
-    readonly removeOnChange: <K extends import("..").KeyOf<import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1] | undefined, previousValue?: PropMap[K_1] | undefined) => void; }>>, H extends import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1] | undefined, previousValue?: PropMap[K_1] | undefined) => void; }>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
-    readonly control: <K extends import("..").KeyOf<import("..").GetEventsMap<{
-        before: <K_1 extends import("..").KeyOf<PropMap>, V extends PropMap[K_1]>(name: K_1, value: V | undefined) => boolean;
-        change: (names: import("..").KeyOf<PropMap>[]) => void;
-        reset: () => void;
-        error: import("..").ErrorListenerSignature<any[]>;
-        effect: <K_1 extends import("..").KeyOf<PropMap>, V_1 extends PropMap[K_1]>(name: K_1, value: V_1 | undefined) => void;
-    }>>, H extends import("..").GetEventsMap<{
-        before: <K_1 extends import("..").KeyOf<PropMap>, V extends PropMap[K_1]>(name: K_1, value: V | undefined) => boolean;
-        change: (names: import("..").KeyOf<PropMap>[]) => void;
-        reset: () => void;
-        error: import("..").ErrorListenerSignature<any[]>;
-        effect: <K_1 extends import("..").KeyOf<PropMap>, V_1 extends PropMap[K_1]>(name: K_1, value: V_1 | undefined) => void;
-    }>[K]["signature"]>(name: K, handler: H, options?: import("..").ListenerOptions) => void;
-    readonly removeControl: <K extends import("..").KeyOf<import("..").GetEventsMap<{
-        before: <K_1 extends import("..").KeyOf<PropMap>, V extends PropMap[K_1]>(name: K_1, value: V | undefined) => boolean;
-        change: (names: import("..").KeyOf<PropMap>[]) => void;
-        reset: () => void;
-        error: import("..").ErrorListenerSignature<any[]>;
-        effect: <K_1 extends import("..").KeyOf<PropMap>, V_1 extends PropMap[K_1]>(name: K_1, value: V_1 | undefined) => void;
-    }>>, H extends import("..").GetEventsMap<{
-        before: <K_1 extends import("..").KeyOf<PropMap>, V extends PropMap[K_1]>(name: K_1, value: V | undefined) => boolean;
-        change: (names: import("..").KeyOf<PropMap>[]) => void;
-        reset: () => void;
-        error: import("..").ErrorListenerSignature<any[]>;
-        effect: <K_1 extends import("..").KeyOf<PropMap>, V_1 extends PropMap[K_1]>(name: K_1, value: V_1 | undefined) => void;
-    }>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
-    readonly pipe: <K extends import("..").KeyOf<import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1] | undefined) => PropMap[K_1]; }>>, H extends import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1] | undefined) => PropMap[K_1]; }>[K]["signature"]>(name: K, handler: H, options?: import("..").ListenerOptions) => void;
-    readonly removePipe: <K extends import("..").KeyOf<import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1] | undefined) => PropMap[K_1]; }>>, H extends import("..").GetEventsMap<{ [K_1 in import("..").KeyOf<PropMap>]: (value: PropMap[K_1] | undefined) => PropMap[K_1]; }>[K]["signature"]>(name: K, handler: H, context?: object | null, tag?: string | null) => void;
-}>;
+}>(initialData?: Partial<PropMap>, config?: Config): ReturnType<typeof createStore<PropMap>>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kuindji/reactive",
-    "version": "1.0.9",
+    "version": "1.0.11",
     "description": "A JavaScript/TypeScript utility library for building reactive applications with events, actions, stores, and React hooks",
     "keywords": [
         "events",