@daiso-tech/core 0.6.0 → 0.8.0

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

@@ -0,0 +1,100 @@
+/**
+ * @module Collection
+ */
+import { type Collapse, type Comparator, type Predicate, type ForEach, type ICollection, type Map, type Modifier, type Tap, type Transform, type ChangendItem, type Reduce, type CrossJoinResult } from "../../../collection/contracts/_module";
+import { type Lazyable } from "../../../_shared/types";
+import { type RecordItem } from "../../../_shared/types";
+/**
+ * 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.
+ * @group Adapters
+ */
+export declare class IterableCollection<TInput> implements ICollection<TInput> {
+    private iterable;
+    private static DEFAULT_CHUNK_SIZE;
+    private static makeCollection;
+    /**
+     * The <i>constructor</i> takes an <i>{@link Iterable}</i>.
+     */
+    constructor(iterable: Iterable<TInput>);
+    [Symbol.iterator](): Iterator<TInput>;
+    toIterator(): Iterator<TInput, void>;
+    entries(): ICollection<RecordItem<number, TInput>>;
+    keys(): ICollection<number>;
+    values(): ICollection<TInput>;
+    filter<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): ICollection<TOutput>;
+    reject<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): ICollection<Exclude<TInput, TOutput>>;
+    map<TOutput>(mapFn: Map<TInput, ICollection<TInput>, TOutput>): ICollection<TOutput>;
+    reduce(reduceFn: Reduce<TInput, ICollection<TInput>, TInput>): TInput;
+    reduce(reduceFn: Reduce<TInput, ICollection<TInput>, TInput>, initialValue: TInput): TInput;
+    reduce<TOutput>(reduceFn: Reduce<TInput, ICollection<TInput>, TOutput>, initialValue: TOutput): TOutput;
+    join(separator?: string): Extract<TInput, string>;
+    collapse(): ICollection<Collapse<TInput>>;
+    flatMap<TOutput>(mapFn: Map<TInput, ICollection<TInput>, Iterable<TOutput>>): ICollection<TOutput>;
+    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    page(page: number, pageSize: number): ICollection<TInput>;
+    sum(): Extract<TInput, number>;
+    average(): Extract<TInput, number>;
+    median(): Extract<TInput, number>;
+    min(): Extract<TInput, number>;
+    max(): Extract<TInput, number>;
+    percentage(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
+    some<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): boolean;
+    every<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): boolean;
+    take(limit: number): ICollection<TInput>;
+    takeUntil(predicateFn: Predicate<TInput, ICollection<TInput>>): ICollection<TInput>;
+    takeWhile(predicateFn: Predicate<TInput, ICollection<TInput>>): ICollection<TInput>;
+    skip(offset: number): ICollection<TInput>;
+    skipUntil(predicateFn: Predicate<TInput, ICollection<TInput>>): ICollection<TInput>;
+    skipWhile<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): ICollection<TInput>;
+    when<TExtended = TInput>(condition: boolean, callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    whenEmpty<TExtended = TInput>(callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    whenNot<TExtended = TInput>(condition: boolean, callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    whenNotEmpty<TExtended = TInput>(callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    pipe<TOutput = TInput>(callback: Transform<ICollection<TInput>, TOutput>): TOutput;
+    tap(callback: Tap<ICollection<TInput>>): ICollection<TInput>;
+    chunk(chunkSize: number): ICollection<ICollection<TInput>>;
+    chunkWhile(predicateFn: Predicate<TInput, ICollection<TInput>>): ICollection<ICollection<TInput>>;
+    split(chunkAmount: number): ICollection<ICollection<TInput>>;
+    partition(predicateFn: Predicate<TInput, ICollection<TInput>>): ICollection<ICollection<TInput>>;
+    sliding(chunkSize: number, step?: number): ICollection<ICollection<TInput>>;
+    groupBy<TOutput = TInput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<RecordItem<TOutput, ICollection<TInput>>>;
+    countBy<TOutput = TInput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<RecordItem<TOutput, number>>;
+    unique<TOutput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<TInput>;
+    difference<TOutput = TInput>(iterable: Iterable<TInput>, mapFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<TInput>;
+    repeat(amount: number): ICollection<TInput>;
+    padStart<TExtended = TInput>(maxLength: number, fillItems: Iterable<TExtended>): ICollection<TInput | TExtended>;
+    padEnd<TExtended = TInput>(maxLength: number, fillItems: Iterable<TExtended>): ICollection<TInput | TExtended>;
+    slice(start?: number, end?: number): ICollection<TInput>;
+    prepend<TExtended = TInput>(iterable: Iterable<TInput | TExtended>): ICollection<TInput | TExtended>;
+    append<TExtended = TInput>(iterable: Iterable<TInput | TExtended>): ICollection<TInput | TExtended>;
+    insertBefore<TExtended = TInput>(predicateFn: Predicate<TInput, ICollection<TInput>>, iterable: Iterable<TInput | TExtended>): ICollection<TInput | TExtended>;
+    insertAfter<TExtended = TInput>(predicateFn: Predicate<TInput, ICollection<TInput>>, iterable: Iterable<TInput | TExtended>): ICollection<TInput | TExtended>;
+    crossJoin<TExtended>(iterable: Iterable<TExtended>): ICollection<CrossJoinResult<TInput, TExtended>>;
+    zip<TExtended>(iterable: Iterable<TExtended>): ICollection<RecordItem<TInput, TExtended>>;
+    sort(comparator?: Comparator<TInput>): ICollection<TInput>;
+    reverse(chunkSize?: number): ICollection<TInput>;
+    shuffle(mathRandom?: () => number): ICollection<TInput>;
+    first<TOutput extends TInput>(predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput | null;
+    firstOr<TOutput extends TInput, TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput | TExtended;
+    firstOrFail<TOutput extends TInput>(predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput;
+    last<TOutput extends TInput>(predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput | null;
+    lastOr<TOutput extends TInput, TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput | TExtended;
+    lastOrFail<TOutput extends TInput>(predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput;
+    before(predicateFn: Predicate<TInput, ICollection<TInput>>): TInput | null;
+    beforeOr<TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn: Predicate<TInput, ICollection<TInput>>): TInput | TExtended;
+    beforeOrFail(predicateFn: Predicate<TInput, ICollection<TInput>>): TInput;
+    after(predicateFn: Predicate<TInput, ICollection<TInput>>): TInput | null;
+    afterOr<TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn: Predicate<TInput, ICollection<TInput>>): TInput | TExtended;
+    afterOrFail(predicateFn: Predicate<TInput, ICollection<TInput>>): TInput;
+    sole<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput;
+    nth(step: number): ICollection<TInput>;
+    count(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
+    size(): number;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    searchFirst(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
+    searchLast(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
+    forEach(callback: ForEach<TInput, ICollection<TInput>>): void;
+    toArray(): TInput[];
+}

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

@@ -0,0 +1 @@
+export * from "../../../collection/implementations/list-collection/list-collection";

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

@@ -0,0 +1,97 @@
+/**
+ * @module Collection
+ */
+import { type Collapse, type Comparator, type Predicate, type ICollection, type Map, type Modifier, type Tap, type Transform, type ChangendItem, type Reduce, type ForEach, type CrossJoinResult } from "../../../collection/contracts/_module";
+import { type Lazyable } from "../../../_shared/types";
+import { type RecordItem } from "../../../_shared/types";
+/**
+ * All methods in <i>ListCollection</i> are executed eagerly.
+ * @group Adapters
+ */
+export declare class ListCollection<TInput> implements ICollection<TInput> {
+    private array;
+    /**
+     * The <i>constructor</i> takes an <i>{@link Iterable}</i>.
+     */
+    constructor(iterable?: Iterable<TInput>);
+    [Symbol.iterator](): Iterator<TInput>;
+    toIterator(): Iterator<TInput, void>;
+    entries(): ICollection<RecordItem<number, TInput>>;
+    keys(): ICollection<number>;
+    values(): ICollection<TInput>;
+    filter<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): ICollection<TOutput>;
+    reject<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): ICollection<Exclude<TInput, TOutput>>;
+    map<TOutput>(mapFn: Map<TInput, ICollection<TInput>, TOutput>): ICollection<TOutput>;
+    reduce(reduceFn: Reduce<TInput, ICollection<TInput>, TInput>): TInput;
+    reduce(reduceFn: Reduce<TInput, ICollection<TInput>, TInput>, initialValue: TInput): TInput;
+    reduce<TOutput>(reduceFn: Reduce<TInput, ICollection<TInput>, TOutput>, initialValue: TOutput): TOutput;
+    join(separator?: string): Extract<TInput, string>;
+    collapse(): ICollection<Collapse<TInput>>;
+    flatMap<TOutput>(mapFn: Map<TInput, ICollection<TInput>, Iterable<TOutput>>): ICollection<TOutput>;
+    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    page(page: number, pageSize: number): ICollection<TInput>;
+    sum(): Extract<TInput, number>;
+    average(): Extract<TInput, number>;
+    median(): Extract<TInput, number>;
+    min(): Extract<TInput, number>;
+    max(): Extract<TInput, number>;
+    percentage(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
+    some<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): boolean;
+    every<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): boolean;
+    take(limit: number): ICollection<TInput>;
+    takeUntil(predicateFn: Predicate<TInput, ICollection<TInput>>): ICollection<TInput>;
+    takeWhile(predicateFn: Predicate<TInput, ICollection<TInput>>): ICollection<TInput>;
+    skip(offset: number): ICollection<TInput>;
+    skipUntil(predicateFn: Predicate<TInput, ICollection<TInput>>): ICollection<TInput>;
+    skipWhile(predicateFn: Predicate<TInput, ICollection<TInput>>): ICollection<TInput>;
+    when<TExtended = TInput>(condition: boolean, callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    whenEmpty<TExtended = TInput>(callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    whenNot<TExtended = TInput>(condition: boolean, callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    whenNotEmpty<TExtended = TInput>(callback: Modifier<ICollection<TInput>, ICollection<TExtended>>): ICollection<TInput | TExtended>;
+    pipe<TOutput = TInput>(callback: Transform<ICollection<TInput>, TOutput>): TOutput;
+    tap(callback: Tap<ICollection<TInput>>): ICollection<TInput>;
+    chunk(chunkSize: number): ICollection<ICollection<TInput>>;
+    chunkWhile(predicateFn: Predicate<TInput, ICollection<TInput>>): ICollection<ICollection<TInput>>;
+    split(chunkAmount: number): ICollection<ICollection<TInput>>;
+    partition(predicateFn: Predicate<TInput, ICollection<TInput>>): ICollection<ICollection<TInput>>;
+    sliding(chunkSize: number, step?: number): ICollection<ICollection<TInput>>;
+    groupBy<TOutput = TInput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<RecordItem<TOutput, ICollection<TInput>>>;
+    countBy<TOutput = TInput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<RecordItem<TOutput, number>>;
+    unique<TOutput = TInput>(selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<TInput>;
+    difference<TOutput = TInput>(iterable: Iterable<TInput>, selectFn?: Map<TInput, ICollection<TInput>, TOutput>): ICollection<TInput>;
+    repeat(amount: number): ICollection<TInput>;
+    padStart<TExtended = TInput>(maxLength: number, fillItems: Iterable<TExtended>): ICollection<TInput | TExtended>;
+    padEnd<TExtended = TInput>(maxLength: number, fillItems: Iterable<TExtended>): ICollection<TInput | TExtended>;
+    slice(start?: number, end?: number): ICollection<TInput>;
+    prepend<TExtended = TInput>(iterable: Iterable<TInput | TExtended>): ICollection<TInput | TExtended>;
+    append<TExtended = TInput>(iterable: Iterable<TInput | TExtended>): ICollection<TInput | TExtended>;
+    insertBefore<TExtended = TInput>(predicateFn: Predicate<TInput, ICollection<TInput>>, iterable: Iterable<TInput | TExtended>): ICollection<TInput | TExtended>;
+    insertAfter<TExtended = TInput>(predicateFn: Predicate<TInput, ICollection<TInput>>, iterable: Iterable<TInput | TExtended>): ICollection<TInput | TExtended>;
+    crossJoin<TExtended>(iterable: Iterable<TExtended>): ICollection<CrossJoinResult<TInput, TExtended>>;
+    zip<TExtended>(iterable: Iterable<TExtended>): ICollection<RecordItem<TInput, TExtended>>;
+    sort(comparator?: Comparator<TInput>): ICollection<TInput>;
+    reverse(_chunkSize?: number): ICollection<TInput>;
+    shuffle(mathRandom?: () => number): ICollection<TInput>;
+    first<TOutput extends TInput>(predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput | null;
+    firstOr<TOutput extends TInput, TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput | TExtended;
+    firstOrFail<TOutput extends TInput>(predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput;
+    last<TOutput extends TInput>(predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput | null;
+    lastOr<TOutput extends TInput, TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput | TExtended;
+    lastOrFail<TOutput extends TInput>(predicateFn?: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput;
+    before(predicateFn: Predicate<TInput, ICollection<TInput>>): TInput | null;
+    beforeOr<TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn: Predicate<TInput, ICollection<TInput>>): TInput | TExtended;
+    beforeOrFail(predicateFn: Predicate<TInput, ICollection<TInput>>): TInput;
+    after(predicateFn: Predicate<TInput, ICollection<TInput>>): TInput | null;
+    afterOr<TExtended = TInput>(defaultValue: Lazyable<TExtended>, predicateFn: Predicate<TInput, ICollection<TInput>>): TInput | TExtended;
+    afterOrFail(predicateFn: Predicate<TInput, ICollection<TInput>>): TInput;
+    sole<TOutput extends TInput>(predicateFn: Predicate<TInput, ICollection<TInput>, TOutput>): TOutput;
+    nth(step: number): ICollection<TInput>;
+    count(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
+    size(): number;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    searchFirst(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
+    searchLast(predicateFn: Predicate<TInput, ICollection<TInput>>): number;
+    forEach(callback: ForEach<TInput, ICollection<TInput>>): void;
+    toArray(): TInput[];
+}

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

@@ -0,0 +1,4 @@
+export * from "../../event-bus/contracts/_shared";
+export * from "../../event-bus/contracts/event-bus.contract";
+export * from "../../event-bus/contracts/event-bus-adapter.contract";
+export * from "../../event-bus/contracts/event-bus-manager.contract";

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

@@ -0,0 +1,32 @@
+/**
+ * @module EventBus
+ */
+import type { Promisable } from "../../_shared/types";
+export type IBaseEvent = {
+    type: string;
+};
+export type Listener<TEvent extends IBaseEvent> = (event: TEvent) => Promisable<void>;
+/**
+ * @group Errors
+ */
+export declare class EventBusError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class RemoveListenerEventBusError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class AddListenerEventBusError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * @group Errors
+ */
+export declare class DispatchEventBusError extends Error {
+    constructor(message: string, cause?: unknown);
+}

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

@@ -0,0 +1,23 @@
+/**
+ * @module EventBus
+ */
+import type { IBaseEvent, Listener } from "../../event-bus/contracts/_shared";
+/**
+ * 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>
+ * @group Contracts
+ */
+export type IEventBusAdapter = {
+    /**
+     * The <i>addListener</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i>.
+     */
+    addListener(event: 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>.
+     */
+    removeListener(event: 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>;
+};

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

@@ -0,0 +1,20 @@
+/**
+ * @module EventBus
+ */
+import type { Validator } from "../../utilities/_module";
+import type { INamespacedEventBus } from "../../event-bus/contracts/event-bus.contract";
+import type { IBaseEvent } from "../../event-bus/contracts/_shared";
+/**
+ * @group Contracts
+ */
+export type EventBusManagerUseSettings<TType, TAdapters extends string = string> = {
+    adapter?: TAdapters;
+    validator?: Validator<TType>;
+};
+/**
+ * The <i>IEventBusManager</i> contract makes it easy to switch between different <i>{@link IEventBusAdapter | event bus adapters}</i> dynamically.
+ * @group Contracts
+ */
+export type IEventBusManager<TAdapters extends string = string> = {
+    use<TEvents extends IBaseEvent = IBaseEvent>(settings?: EventBusManagerUseSettings<TEvents, TAdapters>): INamespacedEventBus<TEvents>;
+};

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

@@ -0,0 +1,91 @@
+/**
+ * @module EventBus
+ */
+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;
+}>;
+export type Unsubscribe = () => PromiseLike<void>;
+/**
+ * The <i>IListenable</i> contract defines a way listening to events independent of underlying technology
+ * @throws {EventBusError} {@link EventBusError}
+ * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
+ * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
+ * @group Contracts
+ */
+export type IListenable<TEvents extends IBaseEvent = IBaseEvent> = {
+    /**
+     * 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 {EventBusError} {@link EventBusError}
+     * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
+     */
+    addListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<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 {EventBusError} {@link EventBusError}
+     * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
+     */
+    addListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<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 {EventBusError} {@link EventBusError}
+     * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
+     */
+    removeListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<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 {EventBusError} {@link EventBusError}
+     * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
+     */
+    removeListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<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.
+     * @throws {EventBusError} {@link EventBusError}
+     * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
+     */
+    subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
+    subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
+};
+/**
+ * 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>.
+ * @throws {EventBusError} {@link EventBusError}
+ * @throws {DispatchEventBusError} {@link DispatchEventBusError}
+ * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
+ * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
+ * @group Contracts
+ */
+export type IEventBus<TEvents extends IBaseEvent = IBaseEvent> = IListenable<TEvents> & {
+    /**
+     * The <i>dispatch</i> method is used for dispatching one or multiple <i>events</i>.
+     * @throws {EventBusError} {@link EventBusError}
+     * @throws {DispatchEventBusError} {@link DispatchEventBusError}
+     */
+    dispatch(events: OneOrMore<TEvents>): PromiseLike<void>;
+};
+/**
+ * The <i>INamespacedEventBus</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>.
+ * @throws {EventBusError} {@link EventBusError}
+ * @throws {DispatchEventBusError} {@link DispatchEventBusError}
+ * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
+ * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
+ * @group Contracts
+ */
+export type INamespacedEventBus<TEvents extends IBaseEvent = IBaseEvent> = 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>.
+     * This useful for multitennat applications.
+     */
+    withNamespace(namespace: string): IEventBus<TEvents>;
+    /**
+     * The <i>getNamespace</i> method return the complete namespace.
+     */
+    getNamespace(): string;
+};

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

@@ -0,0 +1,5 @@
+export * from "../../event-bus/implementations/_shared/test-utilities/_module";
+export * from "../../event-bus/implementations/event-bus/_module";
+export * from "../../event-bus/implementations/memory-event-bus-adapter/_module";
+export * from "../../event-bus/implementations/redis-event-bus-adapter/_module";
+export * from "../../event-bus/implementations/no-op-event-bus-adapter/_module";

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

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

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

@@ -0,0 +1,20 @@
+/**
+ * @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 "../../../../_shared/types";
+/**
+ * @group Utilities
+ */
+export type EventBusTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapter: () => Promisable<IEventBusAdapter>;
+};
+/**
+ * @group Utilities
+ */
+export declare function eventBusTestSuite(settings: EventBusTestSuiteSettings): void;

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

@@ -0,0 +1,2 @@
+export * from "../../../event-bus/implementations/event-bus/event-bus";
+export * from "../../../event-bus/implementations/event-bus/event-bus-manager";

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

@@ -0,0 +1,23 @@
+/**
+ * @module EventBus
+ */
+import type { INamespacedEventBus, IEventBusAdapter, IEventBusManager, EventBusManagerUseSettings, IBaseEvent } from "../../../event-bus/contracts/_module";
+import { type EventBusSettings } from "../../../event-bus/implementations/event-bus/event-bus";
+/**
+ * @group Derivables
+ */
+export type EventBusManagerSettings<TAdapters extends string = string> = {
+    adapters: Record<TAdapters, IEventBusAdapter>;
+    defaultAdapter: NoInfer<TAdapters>;
+    adapterSettings?: Omit<EventBusSettings<any>, "validator">;
+};
+/**
+ * @group Derivables
+ */
+export declare class EventBusManager<TAdapters extends string = string> implements IEventBusManager<TAdapters> {
+    private readonly adapters;
+    private readonly defaultAdapter;
+    private readonly adapterSettings;
+    constructor(settings: EventBusManagerSettings<TAdapters>);
+    use<TEvents extends IBaseEvent = IBaseEvent>(adapterSettings: EventBusManagerUseSettings<TEvents, TAdapters>): INamespacedEventBus<TEvents>;
+}

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

@@ -0,0 +1,102 @@
+/**
+ * @module EventBus
+ */
+import type { Validator } from "../../../utilities/_module";
+import { LazyPromise } from "../../../utilities/_module";
+import type { SelectEvent, Unsubscribe } from "../../../event-bus/contracts/_module";
+import { type IEventBus, type INamespacedEventBus, type IEventBusAdapter, type Listener, type IBaseEvent } from "../../../event-bus/contracts/_module";
+import type { OneOrMore } from "../../../_shared/types";
+/**
+ * @group Derivables
+ */
+export type EventBusSettings<TEvents extends IBaseEvent> = {
+    /**
+     * You can prefix all keys with a given <i>namespace</i>.
+     * This useful if you want to add multitenancy but still use the same database.
+     * @default {""}
+     * @example
+     * ```ts
+     * import { EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
+     *
+     * const eventBusA = new EventBus(new MemoryEventBusAdapter(), {
+     *   rootNamespace: "@a/"
+     * });
+     * const eventBusB = new EventBus(new MemoryEventBusAdapter(), {
+     *   rootNamespace: "@b/"
+     * });
+     *
+     * (async () => {
+     *   eventBusB.addListener("add", event => {
+     *     // This will never be logged because eventBusB has different namespace
+     *     console.log("eventBusB:", event);
+     *   });
+     *
+     *   eventBusB.addListener("add", event => {
+     *     // This will be logged
+     *     console.log("eventBusB:", event);
+     *   });
+     *
+     *   await eventBusA.dispatch([
+     *     { type: "add", a: 1, b: 2 }
+     *   ]);
+     * })();
+     * ```
+     */
+    rootNamespace?: string;
+    /**
+     * You can pass a custom <i>{@link Validator}</i> to validate, transform and sanitize your data.
+     * You could also use <i>{@link zodValidator}</i> which enables you to use zod for validating, transforming, and sanitizing.
+     * @example
+     * ```ts
+     * import { EventBus, MemoryEventBusAdapter, zodValidator } from "@daiso-tech/core";
+     * import { z } from "zod";
+     *
+     * const addEventSchema = z.object({
+     *   type: z.literal("add"),
+     *   a: z.number(),
+     *   b: z.number(),
+     * });
+     *
+     * const subEventSchema = z.object({
+     *   type: z.literal("sub"),
+     *   c: z.number(),
+     *   d: z.number(),
+     * });
+     *
+     * const eventBus = new EventBus(new MemoryEventBusAdapter(), {
+     *   // Event type will be infered from validator
+     *   validator: zodValidator(addEventSchema.or(subEventSchema))
+     * });
+     *
+     * (async () => {
+     *   // An Typescript error will be seen and ValidationError will be thrown during runtime.
+     *   await eventBus.dispatch([
+     *     {
+     *       type: "none existing",
+     *       noneExistingField: 20
+     *     }
+     *   ]);
+     * })();
+     * ```
+     */
+    validator?: Validator<TEvents>;
+};
+/**
+ * <i>EventBus</i> class can be derived from any <i>{@link IEventBusAdapter}</i>.
+ * @group Derivables
+ */
+export declare class EventBus<TEvents extends IBaseEvent = IBaseEvent> implements INamespacedEventBus<TEvents> {
+    private readonly eventBusAdapter;
+    private readonly namespace_;
+    private readonly validator;
+    constructor(eventBusAdapter: IEventBusAdapter, settings?: EventBusSettings<TEvents>);
+    withNamespace(namespace: string): IEventBus<TEvents>;
+    getNamespace(): string;
+    addListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    addListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    removeListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    removeListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
+    subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
+    subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
+    dispatch(events: OneOrMore<TEvents>): LazyPromise<void>;
+}

package/dist/types/event-bus/implementations/event-bus/with-namespace-event-bus-adapter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @module EventBus
+ */
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+/**
+ * @internal
+ */
+export declare class WithNamespaceEventBusAdapter implements IEventBusAdapter {
+    private readonly eventBusAdapter;
+    private readonly namespace;
+    private readonly listenerMap;
+    constructor(eventBusAdapter: IEventBusAdapter, namespace: string);
+    addListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(events: IBaseEvent[]): Promise<void>;
+}

package/dist/types/event-bus/implementations/event-bus/with-validation-event-bus-adapter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module EventBus
+ */
+import type { Validator } from "../../../utilities/_module";
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+/**
+ * @internal
+ */
+export declare class WithValidationEventBusAdapter implements IEventBusAdapter {
+    private readonly eventBusAdapter;
+    private readonly validator;
+    private readonly listenerMap;
+    constructor(eventBusAdapter: IEventBusAdapter, validator: Validator<IBaseEvent>);
+    addListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(events: IBaseEvent[]): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export * from "../../../event-bus/implementations/memory-event-bus-adapter/_module";

package/dist/types/event-bus/implementations/memory-event-bus-adapter/memory-event-bus-adapter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module EventBus
+ */
+import type { IBaseEvent, IEventBusAdapter, Listener } from "../../../event-bus/contracts/_module";
+import { EventEmitter } from "node:events";
+/**
+ * @group Adapters
+ */
+export declare class MemoryEventBusAdapter implements IEventBusAdapter {
+    private readonly eventEmiter;
+    constructor(eventEmiter?: EventEmitter<[never]>);
+    addListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(event: string, listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(events: IBaseEvent[]): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export * from "../../../event-bus/implementations/no-op-event-bus-adapter/no-op-event-bus-adapter";

package/dist/types/event-bus/implementations/no-op-event-bus-adapter/no-op-event-bus-adapter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @module EventBus
+ */
+import type { Listener, IBaseEvent } from "../../../_module";
+import type { IEventBusAdapter } from "../../../event-bus/contracts/event-bus-adapter.contract";
+/**
+ * This <i>NoOpEventBusAdapter</i> will do nothing and is used for easily mocking IEventBus for testing.
+ * @group Adapters
+ */
+export declare class NoOpEventBusAdapter implements IEventBusAdapter {
+    addListener(_event: string, _listener: Listener<IBaseEvent>): Promise<void>;
+    removeListener(_event: string, _listener: Listener<IBaseEvent>): Promise<void>;
+    dispatch(_events: IBaseEvent[]): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export * from "../../../event-bus/implementations/memory-event-bus-adapter/_module";