@daiso-tech/core 0.14.0 → 0.16.0

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-pad-end-iterable.d.ts

@@ -2,7 +2,7 @@
  * @module Collection
  */
 import { type IAsyncCollection } from "../../../../collection/contracts/_module";
-import { type AsyncIterableValue } from "../../../../_shared/types";
+import { type AsyncIterableValue } from "../../../../utilities/_module";
 /**
  * @internal
  */

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-pad-start-iterable.d.ts

@@ -2,7 +2,7 @@
  * @module Collection
  */
 import { type IAsyncCollection } from "../../../../collection/contracts/_module";
-import { type AsyncIterableValue } from "../../../../_shared/types";
+import { type AsyncIterableValue } from "../../../../utilities/_module";
 /**
  * @internal
  */

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-partion-iterable.d.ts

@@ -2,7 +2,7 @@
  * @module Collection
  */
 import { type AsyncPredicate, type IAsyncCollection } from "../../../../collection/contracts/_module";
-import { type AsyncIterableValue } from "../../../../_shared/types";
+import { type AsyncIterableValue } from "../../../../utilities/_module";
 /**
  * @internal
  */

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-repeat-iterable.d.ts

@@ -2,7 +2,7 @@
  * @module Collection
  */
 import { type IAsyncCollection } from "../../../../collection/contracts/_module";
-import { type AsyncIterableValue } from "../../../../_shared/types";
+import { type AsyncIterableValue } from "../../../../utilities/_module";
 /**
  * @internal
  */

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-retry-iterable.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Collection
+ */
+import { type RetrySettings } from "../../../../async/utilities/retry/_module";
+/**
+ * @internal
+ */
+export declare class AsyncRetryIterable<TValue> implements AsyncIterable<TValue> {
+    private readonly iterable;
+    private readonly settings?;
+    constructor(iterable: AsyncIterable<TValue>, settings?: RetrySettings | undefined);
+    [Symbol.asyncIterator](): AsyncIterator<TValue>;
+}

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-reverse-iterable.d.ts

@@ -2,7 +2,7 @@
  * @module Collection
  */
 import { type IAsyncCollection } from "../../../../collection/contracts/_module";
-import { type AsyncIterableValue } from "../../../../_shared/types";
+import { type AsyncIterableValue } from "../../../../utilities/_module";
 /**
  * @internal
  */

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-split-iterable.d.ts

@@ -2,7 +2,7 @@
  * @module Collection
  */
 import { type IAsyncCollection } from "../../../../collection/contracts/_module";
-import { type AsyncIterableValue } from "../../../../_shared/types";
+import { type AsyncIterableValue } from "../../../../utilities/_module";
 /**
  * @internal
  */

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-take-until-abort-iterable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @internal
+ */
+export declare class AsyncTakeUntilAbortIterable<TValue> implements AsyncIterable<TValue> {
+    private readonly iterable;
+    private readonly abortSignal;
+    constructor(iterable: AsyncIterable<TValue>, abortSignal: AbortSignal);
+    [Symbol.asyncIterator](): AsyncIterator<TValue>;
+}

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-take-until-timeout-iterable.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Collection
+ */
+import { type TimeSpan } from "../../../../utilities/_module";
+/**
+ * @internal
+ */
+export declare class AsyncTakeUntilTimeoutIterable<TInput> implements AsyncIterable<TInput> {
+    private readonly iterable;
+    private readonly time;
+    constructor(iterable: AsyncIterable<TInput>, time: TimeSpan);
+    [Symbol.asyncIterator](): AsyncIterator<TInput>;
+}

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-zip-iterable.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Collection
  */
-import { type AsyncIterableValue } from "../../../../_shared/types";
+import { type AsyncIterableValue } from "../../../../utilities/_module";
 /**
  * @internal
  */

package/dist/types/collection/implementations/async-iterable-collection/async-iterable-collection.d.ts

@@ -3,9 +3,10 @@
  */
 import type { EnsureMap, EnsureRecord } from "../../../collection/contracts/_module";
 import { type AsyncCollapse, type AsyncPredicate, type AsyncForEach, type AsyncMap, type AsyncModifier, type AsyncTap, type AsyncTransform, type Comparator, type IAsyncCollection, type AsyncReduce, type CrossJoinResult } from "../../../collection/contracts/_module";
-import { type AsyncIterableValue, type AsyncLazyable } from "../../../_shared/types";
+import { type AsyncIterableValue, type AsyncLazyable } from "../../../utilities/_module";
 import type { TimeSpan } from "../../../utilities/_module";
-import { LazyPromise } from "../../../utilities/_module";
+import type { LazyPromiseSettings } from "../../../async/_module";
+import { LazyPromise } from "../../../async/_module";
 /**
  * All methods that return <i>{@link IAsyncCollection}</i> are executed lazly.
  * The methods that return <i>{@link IAsyncCollection}</i> will only be executed when <i>forEach</i> method is called or <i>for await</i> loop.
@@ -14,12 +15,17 @@ import { LazyPromise } from "../../../utilities/_module";
  */
 export declare class AsyncIterableCollection<TInput> implements IAsyncCollection<TInput> {
     private readonly iterable;
+    private readonly settings;
+    static concat<TValue>(iterables: AsyncIterableValue<AsyncIterableValue<TValue>>): IAsyncCollection<TValue>;
+    static difference<TValue, TSelect>(iterableA: AsyncIterableValue<TValue>, iterableB: AsyncIterableValue<TValue>, selectFn?: AsyncMap<TValue, IAsyncCollection<TValue>, TSelect>): IAsyncCollection<TValue>;
+    static zip<TValueA, TValueB>(iterableA: AsyncIterableValue<TValueA>, iterableB: AsyncIterableValue<TValueB>): IAsyncCollection<[TValueA, TValueB]>;
     private static DEFAULT_CHUNK_SIZE;
     private static makeCollection;
     /**
      * The <i>constructor</i> takes an <i>{@link Iterable}</i> or <i>{@link AsyncIterable}</i>.
      */
-    constructor(iterable?: AsyncIterableValue<TInput>);
+    constructor(iterable?: AsyncIterableValue<TInput>, settings?: LazyPromiseSettings);
+    private createLazyPromise;
     [Symbol.asyncIterator](): AsyncIterator<TInput>;
     toIterator(): AsyncIterator<TInput, void>;
     entries(): IAsyncCollection<[number, TInput]>;
@@ -97,7 +103,7 @@ export declare class AsyncIterableCollection<TInput> implements IAsyncCollection
     nth(step: number): IAsyncCollection<TInput>;
     delay(time: TimeSpan): IAsyncCollection<TInput>;
     takeUntilAbort(abortSignal: AbortSignal): IAsyncCollection<TInput>;
-    takeUntilTimeout(timeInMs: TimeSpan): IAsyncCollection<TInput>;
+    takeUntilTimeout(time: TimeSpan): IAsyncCollection<TInput>;
     count(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>>): LazyPromise<number>;
     size(): LazyPromise<number>;
     isEmpty(): LazyPromise<boolean>;

package/dist/types/collection/implementations/iterable-collection/_shared/merge-iterable.d.ts

@@ -4,9 +4,8 @@
 /**
  * @internal
  */
-export declare class MergeIterable<TInput, TExtended> implements Iterable<TInput | TExtended> {
-    private iterableA;
-    private iterableB;
-    constructor(iterableA: Iterable<TInput>, iterableB: Iterable<TExtended>);
-    [Symbol.iterator](): Iterator<TInput | TExtended>;
+export declare class MergeIterable<TInput> implements Iterable<TInput> {
+    private iterables;
+    constructor(iterables: Iterable<Iterable<TInput>>);
+    [Symbol.iterator](): Iterator<TInput>;
 }

package/dist/types/collection/implementations/iterable-collection/iterable-collection.d.ts

@@ -3,7 +3,7 @@
  */
 import type { EnsureMap, EnsureRecord } from "../../../collection/contracts/_module";
 import { type Collapse, type Comparator, type Predicate, type ForEach, type ICollection, type Map, type Modifier, type Tap, type Transform, type Reduce, type CrossJoinResult } from "../../../collection/contracts/_module";
-import { type Lazyable } from "../../../_shared/types";
+import { type Lazyable } from "../../../utilities/_module";
 /**
  * All methods that return <i>{@link ICollection}</i> are executed lazly which means they will be executed when the <i>IterableCollection</i> is iterated with <i>forEach</i> method or "for of" loop.
  * The rest of the methods are executed eagerly.
@@ -11,6 +11,9 @@ import { type Lazyable } from "../../../_shared/types";
  */
 export declare class IterableCollection<TInput> implements ICollection<TInput> {
     private readonly iterable;
+    static concat<TValue>(iterables: Iterable<Iterable<TValue>>): ICollection<TValue>;
+    static difference<TValue, TSelect>(iterableA: Iterable<TValue>, iterableB: Iterable<TValue>, selectFn?: Map<TValue, ICollection<TValue>, TSelect>): ICollection<TValue>;
+    static zip<TValueA, TValueB>(iterableA: Iterable<TValueA>, iterableB: Iterable<TValueB>): ICollection<[TValueA, TValueB]>;
     private static DEFAULT_CHUNK_SIZE;
     private static makeCollection;
     /**

package/dist/types/collection/implementations/list-collection/list-collection.d.ts

@@ -3,12 +3,15 @@
  */
 import type { EnsureMap, EnsureRecord } from "../../../collection/contracts/_module";
 import { type Collapse, type Comparator, type Predicate, type ICollection, type Map, type Modifier, type Tap, type Transform, type Reduce, type ForEach, type CrossJoinResult } from "../../../collection/contracts/_module";
-import { type Lazyable } from "../../../_shared/types";
+import { type Lazyable } from "../../../utilities/_module";
 /**
  * All methods in <i>ListCollection</i> are executed eagerly.
  * @group Adapters
  */
 export declare class ListCollection<TInput> implements ICollection<TInput> {
+    static concat<TValue>(iterables: Iterable<Iterable<TValue>>): ICollection<TValue>;
+    static difference<TValue, TSelect>(iterableA: Iterable<TValue>, iterableB: Iterable<TValue>, selectFn?: Map<TValue, ICollection<TValue>, TSelect>): ICollection<TValue>;
+    static zip<TValueA, TValueB>(iterableA: Iterable<TValueA>, iterableB: Iterable<TValueB>): ICollection<[TValueA, TValueB]>;
     private array;
     /**
      * The <i>constructor</i> takes an <i>{@link Iterable}</i>.

package/dist/types/event-bus/contracts/_shared.d.ts

@@ -1,8 +1,5 @@
 /**
  * @module EventBus
  */
-import type { Promisable } from "../../_shared/types";
-export type IBaseEvent = {
-    type: string;
-};
-export type Listener<TEvent extends IBaseEvent> = (event: TEvent) => Promisable<void>;
+import type { Promisable } from "../../utilities/_module";
+export type Listener<TEvent> = (event: TEvent) => Promisable<void>;

package/dist/types/event-bus/contracts/event-bus-adapter.contract.d.ts

@@ -1,7 +1,11 @@
 /**
  * @module EventBus
  */
-import type { IBaseEvent, Listener } from "../../event-bus/contracts/_shared";
+import type { Listener } from "../../event-bus/contracts/_shared";
+import type { OneOrMore } from "../../utilities/_module";
+export type IBaseEvent = {
+    type: string;
+};
 /**
  * The <i>IEventBusAdapter</i> contract defines a way for dispatching and listening to events independent of underlying technology.
  * This interface is not meant to be used directly, instead you should use <i>IEventBus</i>
@@ -9,15 +13,17 @@ import type { IBaseEvent, Listener } from "../../event-bus/contracts/_shared";
  */
 export type IEventBusAdapter = {
     /**
-     * The <i>addListener</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i>.
+     * The <i>addListener</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>eventName</i>.
      */
-    addListener(event: string, listener: Listener<IBaseEvent>): PromiseLike<void>;
+    addListener(eventName: string, listener: Listener<IBaseEvent>): PromiseLike<void>;
     /**
-     * The <i>removeListener</i> method is used for removing <i>{@link Listener | listener}</i> for certain <i>event</i>.
+     * The <i>removeListener</i> method is used for removing <i>{@link Listener | listener}</i> for certain <i>eventName</i>.
      */
-    removeListener(event: string, listener: Listener<IBaseEvent>): PromiseLike<void>;
+    removeListener(eventName: string, listener: Listener<IBaseEvent>): PromiseLike<void>;
     /**
      * The <i>dispatch</i> method is used for dispatching one or multiple <i>events</i>.
      */
-    dispatch(events: IBaseEvent[]): PromiseLike<void>;
+    dispatch(event: IBaseEvent): PromiseLike<void>;
+    getGroup(): string;
+    withGroup(group: OneOrMore<string>): IEventBusAdapter;
 };

package/dist/types/event-bus/contracts/event-bus-factory.contract.d.ts

@@ -1,13 +1,12 @@
 /**
  * @module EventBus
  */
-import type { INamespacedEventBus } from "../../event-bus/contracts/event-bus.contract";
-import type { IBaseEvent } from "../../event-bus/contracts/_shared";
+import type { BaseEvents, IGroupableEventBus } from "../../event-bus/contracts/event-bus.contract";
 /**
- * The <i>IEventBusFactory</i> contract makes it easy to configure and switch between different <i>{@link INamespacedEventBus}</i> dynamically.
+ * The <i>IEventBusFactory</i> contract makes it easy to configure and switch between different <i>{@link IGroupableEventBus}</i> dynamically.
  * @group Contracts
  */
-export type IEventBusFactory<TDrivers extends string = string, TEvents extends IBaseEvent = IBaseEvent> = {
+export type IEventBusFactory<TDrivers extends string = string, TEvents extends BaseEvents = BaseEvents> = {
     /**
      * The <i>use</i> method will throw an error if you provide it unregisted driver.
      * If no default driver is defined an error will be thrown by <i>use</i> method.
@@ -29,7 +28,7 @@ export type IEventBusFactory<TDrivers extends string = string, TEvents extends I
      * }
      * ```
      */
-    use(driverName?: TDrivers): INamespacedEventBus<TEvents>;
+    use(driverName?: TDrivers): IGroupableEventBus<TEvents>;
     /**
      * The <i>withTypes</i> method is used to set the event types of the <i>{@link IEventBus}</i>.
      * @example

package/dist/types/event-bus/contracts/event-bus.contract.d.ts

@@ -1,111 +1,142 @@
 /**
  * @module EventBus
  */
-import type { LazyPromise } from "../../utilities/_module";
-import type { OneOrMore } from "../../_shared/types";
-import type { IBaseEvent, Listener } from "../../event-bus/contracts/_shared";
-export type SelectEvent<TEvents extends IBaseEvent, TEventType extends TEvents["type"]> = Extract<TEvents, {
-    type: IBaseEvent extends TEvents ? string : TEventType;
+import type { OneOrMore, Values } from "../../utilities/_module";
+import type { LazyPromise } from "../../async/_module";
+import type { Listener } from "../../event-bus/contracts/_shared";
+export type BaseEvents = Record<string, Record<string, unknown>>;
+export type AllEvents<TEvents extends BaseEvents> = Values<{
+    [TEventName in keyof TEvents]: TEvents[TEventName] & {
+        type: TEventName;
+    };
 }>;
+/**
+ * @group Contracts
+ */
+export type SelectEvent<TEvents extends BaseEvents, TEventName extends keyof TEvents> = {
+    [TEventName in keyof TEvents]: TEvents[TEventName] & {
+        type: TEventName;
+    };
+}[TEventName];
+/**
+ * @group Contracts
+ */
 export type Unsubscribe = () => LazyPromise<void>;
+/**
+ * @group Contracts
+ */
+export type AddListenerSettings = {
+    signal?: AbortSignal;
+};
 /**
  * The <i>IListenable</i> contract defines a way listening to events independent of underlying technology
  * @group Contracts
  */
-export type IListenable<TEvents extends IBaseEvent = IBaseEvent> = {
+export type IListenable<TEvents extends BaseEvents = BaseEvents> = {
     /**
      * The <i>addListener</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
      * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
      */
-    addListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    addListener<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
     /**
      * The <i>addListenerMany</i> method is used for adding multiple <i>{@link Listener | listeners}</i> for certain <i>events</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
      * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
      */
-    addListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    addListenerMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
     /**
      * The <i>removeListener</i> method is used for removing <i>{@link Listener | listener}</i> for certain <i>event</i>.
      * Removing unadded listener will have no effect and nothing will occur.
      * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
      */
-    removeListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    removeListener<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
     /**
      * The <i>removeListener</i> method is used for removing multiple <i>{@link Listener | listeners}</i> for certain <i>event</i>.
      * Removing unadded listener will have no effect and nothing will occur.
      * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
      */
-    removeListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    removeListenerMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
+    /**
+     * The <i>listenOnce</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i> that is trigged only once.
+     * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
+     */
+    listenOnce<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<void>;
     /**
      * The <i>subscribe</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
      */
-    subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<Unsubscribe>;
+    subscribe<TEventName extends keyof TEvents>(eventName: TEventName, listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<Unsubscribe>;
     /**
      * The <i>subscribeMany</i> method is used for adding <i>{@link Listener | listener}</i> for multiple <i>events</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
      */
-    subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventName extends keyof TEvents>(eventNames: TEventName[], listener: Listener<SelectEvent<TEvents, TEventName>>): LazyPromise<Unsubscribe>;
 };
 /**
  * The <i>IDispatcher</i> contract defines a way for dispatching to events independent of underlying technology.
  * @group Contracts
  */
-export type IDispatcher<TEvents extends IBaseEvent = IBaseEvent> = {
+export type IDispatcher<TEvents extends BaseEvents = BaseEvents> = {
+    /**
+     * The <i>dispatch</i> method is used for dispatching a <i>event</i>.
+
+     * @throws {DispatchEventBusError} {@link DispatchEventBusError}
+     */
+    dispatch(event: AllEvents<TEvents>): LazyPromise<void>;
     /**
-     * The <i>dispatch</i> method is used for dispatching one or multiple <i>events</i>.
+     * The <i>dispatchMany</i> method is used for dispatching multiple <i>event</i>.
 
      * @throws {DispatchEventBusError} {@link DispatchEventBusError}
      */
-    dispatch(events: OneOrMore<TEvents>): LazyPromise<void>;
+    dispatchMany(events: AllEvents<TEvents>[]): LazyPromise<void>;
 };
 /**
  * The <i>IEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
  * It commes with more convient methods compared to <i>IEventBusAdapter</i>.
  * @group Contracts
  */
-export type IEventBus<TEvents extends IBaseEvent = IBaseEvent> = IListenable<TEvents> & IDispatcher<TEvents> & {
+export type IEventBus<TEvents extends BaseEvents = BaseEvents> = IListenable<TEvents> & IDispatcher<TEvents> & {
     /**
-     * The <i>getNamespace</i> method returns the complete namespace.
+     * The <i>getGroup</i> method returns the complete group.
      * @example
      * ```ts
      * import { type IEventBus } from "@daiso-tech/core";
      *
      * async function main(eventBus: IEventBus): Promise<void> {
      *   // Will be "@root"
-     *   console.log(eventBus.getNamespace())
+     *   console.log(eventBus.getGroup())
      *
-     *   const eventBusA = eventBus.withNamespace("a");
+     *   const eventBusA = eventBus.withGroup("a");
      *
      *   // Will be "@root/a"
-     *   console.log(eventBusA.getNamespace())
+     *   console.log(eventBusA.getGroup())
      * }
      * ```
      */
-    getNamespace(): string;
+    getGroup(): string;
 };
 /**
- * The <i>INamespacedEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
+ * The <i>IGroupableEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
  * It commes with one extra method which is useful for multitennat applications compared to <i>IEventBus</i>.
  * @group Contracts
  */
-export type INamespacedEventBus<TEvents extends IBaseEvent = IBaseEvent> = IEventBus<TEvents> & {
+export type IGroupableEventBus<TEvents extends BaseEvents = BaseEvents> = IEventBus<TEvents> & {
     /**
-     * The <i>withNamespace</i> method returns new instance of <i>{@link IEventBus}</i> where all the events names will be prefixed with a given <i>namespace</i>.
+     * The <i>withGroup</i> method returns new instance of <i>{@link IEventBus}</i> where all the events names will be prefixed with a given <i>group</i>.
      * This useful for multitennat applications.
      * @example
      * ```ts
      * import { type IEventBus } from "@daiso-tech/core";
      *
      * async function main(eventBus: IEventBus): Promise<void> {
-     *   const eventBusA = eventBus.withNamespace("a");
+     *   const eventBusA = eventBus.withGroup("a");
      *   await eventBusA.subscribe("add", (event) => {
      *     // This will be logged
      *     console.log("eventBusA:", event);
      *   });
      *
-     *   const eventBusB = eventBus.withNamespace("b");
+     *   const eventBusB = eventBus.withGroup("b");
      *   await eventBusB.subscribe("add", (event) => {
      *     // This will never be logged
      *     console.log("eventBusB:", event);
@@ -119,5 +150,5 @@ export type INamespacedEventBus<TEvents extends IBaseEvent = IBaseEvent> = IEven
      * }
      * ```
      */
-    withNamespace(namespace: OneOrMore<string>): IEventBus<TEvents>;
+    withGroup(group: OneOrMore<string>): IEventBus<TEvents>;
 };

package/dist/types/event-bus/contracts/event-bus.errors.d.ts

@@ -16,18 +16,18 @@ export declare class UnexpectedEventBusError extends EventBusError {
 /**
  * @group Errors
  */
-export declare class RemoveListenerEventBusError extends Error {
+export declare class RemoveListenerEventBusError extends UnexpectedEventBusError {
     constructor(message: string, cause?: unknown);
 }
 /**
  * @group Errors
  */
-export declare class AddListenerEventBusError extends Error {
+export declare class AddListenerEventBusError extends UnexpectedEventBusError {
     constructor(message: string, cause?: unknown);
 }
 /**
  * @group Errors
  */
-export declare class DispatchEventBusError extends Error {
+export declare class DispatchEventBusError extends UnexpectedEventBusError {
     constructor(message: string, cause?: unknown);
 }

package/dist/types/event-bus/implementations/_module.d.ts

@@ -1,3 +1,3 @@
-export * from "../../event-bus/implementations/_shared/test-utilities/_module";
+export * from "../../event-bus/implementations/_shared/_module";
 export * from "../../event-bus/implementations/derivables/_module";
 export * from "../../event-bus/implementations/adapters/_module";

package/dist/types/event-bus/implementations/_shared/_module.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../event-bus/implementations/_shared/event-bus-adapter.test-suite";
+export * from "../../../event-bus/implementations/_shared/event-bus.test-suite";

package/dist/types/event-bus/implementations/_shared/event-bus-adapter.test-suite.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @module EventBus
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import type { IEventBusAdapter } from "../../../event-bus/contracts/_module";
+import { type Promisable } from "../../../utilities/_module";
+/**
+ * @group Utilities
+ */
+export type EventBusAdapterTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapterA: () => Promisable<IEventBusAdapter>;
+    createAdapterB: () => Promisable<IEventBusAdapter>;
+};
+/**
+ * The <i>eventBusAdapterTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link IEventBusAdapter}</i> with vitest.
+ * @group Utilities
+ * @example
+ * ```ts
+ * import { describe, test, beforeEach, expect, afterEach } from "vitest";
+ * import type { StartedRedisContainer } from "@testcontainers/redis";
+ * import { RedisContainer } from "@testcontainers/redis";
+ * import Redis from "ioredis";
+ * import { SuperJsonSerde, TimeSpan, RedisPubSubEventBusAdapter, eventBusAdapterTestSuite } from "@daiso-tech/core";
+ *
+ * const timeout = TimeSpan.fromMinutes(2);
+ * describe("class: RedisPubSubEventBusAdapter", () => {
+ *   let dispatcherClient: Redis;
+ *   let listenerClient: Redis;
+ *   let startedContainer: StartedRedisContainer;
+ *   const serde = new SuperJsonSerde();
+ *   beforeEach(async () => {
+ *     startedContainer = await new RedisContainer().start();
+ *     dispatcherClient = new Redis(startedContainer.getConnectionUrl());
+ *     listenerClient = new Redis(startedContainer.getConnectionUrl());
+ *   }, timeout.toMilliseconds());
+ *   afterEach(async () => {
+ *     await dispatcherClient.quit();
+ *     await listenerClient.quit();
+ *     await startedContainer.stop();
+ *   }, timeout.toMilliseconds());
+ *    eventBusAdapterTestSuite({
+ *      createAdapterA: () =>
+ *        new RedisPubSubEventBusAdapter({
+ *          dispatcherClient,
+ *          listenerClient,
+ *          serde,
+ *          rootGroup: "@global"
+ *        }),
+ *      createAdapterB: () =>
+ *        new RedisPubSubEventBusAdapter({
+ *          dispatcherClient,
+ *          listenerClient,
+ *          serde,
+ *          rootGroup: "@global"
+ *        }),
+ *      test,
+ *      beforeEach,
+ *      expect,
+ *      describe,
+ *   });
+ * });
+ * ```
+ */
+export declare function eventBusAdapterTestSuite(settings: EventBusAdapterTestSuiteSettings): void;

package/dist/types/event-bus/implementations/_shared/event-bus.test-suite.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @module EventBus
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import { type IEventBus } from "../../../event-bus/contracts/_module";
+import { type Promisable } from "../../../utilities/_module";
+/**
+ * @group Utilities
+ */
+export type EventBusTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createEventBusA: () => Promisable<IEventBus>;
+    createEventBusB: () => Promisable<IEventBus>;
+};
+/**
+ * The <i>eventBusTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link IEventBus}</i> with vitest.
+ * @group Utilities
+ * @example
+ * ```ts
+ * import { describe, test, beforeEach, expect, afterEach } from "vitest";
+ * import type { StartedRedisContainer } from "@testcontainers/redis";
+ * import { RedisContainer } from "@testcontainers/redis";
+ * import Redis from "ioredis";
+ * import { SuperJsonSerde, TimeSpan, RedisPubSubEventBusAdapter, eventBusTestSuite } from "@daiso-tech/core";
+ *
+ * const timeout = TimeSpan.fromMinutes(2);
+ * describe("class: EventBus", () => {
+ *   let dispatcherClient: Redis;
+ *   let listenerClient: Redis;
+ *   let startedContainer: StartedRedisContainer;
+ *   const serde = new SuperJsonSerde();
+ *   beforeEach(async () => {
+ *     startedContainer = await new RedisContainer().start();
+ *     dispatcherClient = new Redis(startedContainer.getConnectionUrl());
+ *     listenerClient = new Redis(startedContainer.getConnectionUrl());
+ *   }, timeout.toMilliseconds());
+ *   afterEach(async () => {
+ *     await dispatcherClient.quit();
+ *     await listenerClient.quit();
+ *     await startedContainer.stop();
+ *   }, timeout.toMilliseconds());
+ *    eventBusTestSuite({
+ *      createEventBusA: () =>
+ *        new EventBus(
+ *          new RedisPubSubEventBusAdapter({
+ *            dispatcherClient,
+ *            listenerClient,
+ *            serde,
+ *          }),
+ *          { rootGroup: "@a" }
+ *        ),
+ *      createEventBusB: () =>
+ *        new EventBus(
+ *          new RedisPubSubEventBusAdapter({
+ *            dispatcherClient,
+ *            listenerClient,
+ *            serde,
+ *          }),
+ *          { rootGroup: "@b" }
+ *        ),
+ *      test,
+ *      beforeEach,
+ *      expect,
+ *      describe,
+ *   });
+ * });
+ * ```
+ */
+export declare function eventBusTestSuite(settings: EventBusTestSuiteSettings): void;