Variable EventBusFunctionalConst

EventBusFunctional: {
    once: (<T>(eventType, callback) => (() => void));
    waitFor: (<T>(eventType, timeout?) => Promise<T>);
    waitForAll: (<T>(eventTypes, timeout?) => Promise<T[]>);
    race: (<T>(eventTypes, timeout?) => Promise<{
        eventType: string;
        data: T;
    }>);
    filter: (<T>(eventType, predicate, callback) => (() => void));
    map: (<T, R>(eventType, transform, callback) => (() => void));
    debounce: (<T>(eventType, delay, callback) => (() => void));
    throttle: (<T>(eventType, interval, callback) => (() => void));
    buffer: (<T>(eventType, bufferTime, callback) => (() => void));
    replay: (<T>(eventType, bufferSize?) => {
        subscribe: ((callback) => {
            count: number;
            unsubscribe: (() => {
                count: number;
            });
        });
    });
    merge: (<T>(eventTypes, callback) => (() => void));
    stateMachine: (<TState, T>(initialState, transitions) => {
        get state(): TState;
        unsubscribe: (() => void);
    });
    request: (<TRequest, TResponse>(requestEvent, responseEvent, request, timeout?) => Promise<TResponse>);
    eventIterator: (<T>(eventType) => AsyncIterableIterator<T>);
} = ...

Export a namespace with all utilities for easier access

Type declaration

  • once: (<T>(eventType, callback) => (() => void))
      • <T>(eventType, callback): (() => void)

      • Subscribe to an event that will automatically unsubscribe after the first occurrence

        Type Parameters

        • T = ApiCallback<string>

        Parameters

        • eventType: string

          The event type to listen for

        • callback: EventCallback<T>

          The callback to execute once

        Returns (() => void)

        Unsubscribe function

          • (): void

          • Returns void

  • waitFor: (<T>(eventType, timeout?) => Promise<T>)
      • <T>(eventType, timeout?): Promise<T>

      • Wait for a specific event to occur, returning a Promise

        Type Parameters

        • T = ApiCallback<string>

        Parameters

        • eventType: string

          The event type to wait for

        • Optional timeout: number

          Optional timeout in milliseconds

        Returns Promise<T>

        Promise that resolves with the event data

  • waitForAll: (<T>(eventTypes, timeout?) => Promise<T[]>)
      • <T>(eventTypes, timeout?): Promise<T[]>

      • Wait for multiple events to occur (Promise.all pattern)

        Type Parameters

        • T = ApiCallback<string>

        Parameters

        • eventTypes: string[]

          Array of event types to wait for

        • Optional timeout: number

          Optional timeout in milliseconds

        Returns Promise<T[]>

        Promise that resolves when all events have occurred

  • race: (<T>(eventTypes, timeout?) => Promise<{
        eventType: string;
        data: T;
    }>)
      • <T>(eventTypes, timeout?): Promise<{
            eventType: string;
            data: T;
        }>

      • Wait for the first event to occur from a list (Promise.race pattern)

        Type Parameters

        • T = ApiCallback<string>

        Parameters

        • eventTypes: string[]

          Array of event types to race

        • Optional timeout: number

          Optional timeout in milliseconds

        Returns Promise<{
            eventType: string;
            data: T;
        }>

        Promise that resolves with the first event

  • filter: (<T>(eventType, predicate, callback) => (() => void))
      • <T>(eventType, predicate, callback): (() => void)

      • Filter events based on a predicate function

        Type Parameters

        • T = ApiCallback<string>

        Parameters

        • eventType: string

          The event type to filter

        • predicate: ((msg) => boolean)

          Function to test each event

            • (msg): boolean

            • Parameters

              • msg: T

              Returns boolean

        • callback: EventCallback<T>

          Callback for events that pass the filter

        Returns (() => void)

        Unsubscribe function

          • (): void

          • Returns void

  • map: (<T, R>(eventType, transform, callback) => (() => void))
      • <T, R>(eventType, transform, callback): (() => void)

      • Transform events using a map function

        Type Parameters

        • T = ApiCallback<string>
        • R = any

        Parameters

        • eventType: string

          The event type to transform

        • transform: ((msg) => R)

          Function to transform the event data

            • (msg): R

            • Parameters

              • msg: T

              Returns R

        • callback: ((msg) => void)

          Callback for transformed events

            • (msg): void

            • Parameters

              • msg: R

              Returns void

        Returns (() => void)

        Unsubscribe function

          • (): void

          • Returns void

  • debounce: (<T>(eventType, delay, callback) => (() => void))
      • <T>(eventType, delay, callback): (() => void)

      • Debounce events - only emit after a period of inactivity

        Type Parameters

        • T = ApiCallback<string>

        Parameters

        • eventType: string

          The event type to debounce

        • delay: number

          Delay in milliseconds

        • callback: EventCallback<T>

          Callback for debounced events

        Returns (() => void)

        Unsubscribe function

          • (): void

          • Returns void

  • throttle: (<T>(eventType, interval, callback) => (() => void))
      • <T>(eventType, interval, callback): (() => void)

      • Throttle events - limit emissions to once per interval

        Type Parameters

        • T = ApiCallback<string>

        Parameters

        • eventType: string

          The event type to throttle

        • interval: number

          Minimum interval between emissions in milliseconds

        • callback: EventCallback<T>

          Callback for throttled events

        Returns (() => void)

        Unsubscribe function

          • (): void

          • Returns void

  • buffer: (<T>(eventType, bufferTime, callback) => (() => void))
      • <T>(eventType, bufferTime, callback): (() => void)

      • Buffer events and emit them as an array

        Type Parameters

        • T = ApiCallback<string>

        Parameters

        • eventType: string

          The event type to buffer

        • bufferTime: number

          Time window to collect events in milliseconds

        • callback: ((events) => void)

          Callback for buffered events

            • (events): void

            • Parameters

              • events: T[]

              Returns void

        Returns (() => void)

        Unsubscribe function

          • (): void

          • Returns void

  • replay: (<T>(eventType, bufferSize?) => {
        subscribe: ((callback) => {
            count: number;
            unsubscribe: (() => {
                count: number;
            });
        });
    })
      • <T>(eventType, bufferSize?): {
            subscribe: ((callback) => {
                count: number;
                unsubscribe: (() => {
                    count: number;
                });
            });
        }

      • Create a replay subject that remembers the last N events

        Type Parameters

        • T = ApiCallback<string>

        Parameters

        • eventType: string

          The event type to replay

        • bufferSize: number = 1

          Number of events to remember

        Returns {
            subscribe: ((callback) => {
                count: number;
                unsubscribe: (() => {
                    count: number;
                });
            });
        }

        Object with subscribe method that replays buffered events

        • subscribe: ((callback) => {
              count: number;
              unsubscribe: (() => {
                  count: number;
              });
          })
            • (callback): {
                  count: number;
                  unsubscribe: (() => {
                      count: number;
                  });
              }

            • Parameters

              • callback: EventCallback<T>

              Returns {
                  count: number;
                  unsubscribe: (() => {
                      count: number;
                  });
              }

              • count: number
              • unsubscribe: (() => {
                    count: number;
                })
                  • (): {
                        count: number;
                    }

                  • Returns {
                        count: number;
                    }

                    • count: number
  • merge: (<T>(eventTypes, callback) => (() => void))
      • <T>(eventTypes, callback): (() => void)

      • Merge multiple event streams into one

        Type Parameters

        • T = ApiCallback<string>

        Parameters

        • eventTypes: string[]

          Array of event types to merge

        • callback: ((eventType, msg) => void)

          Callback for all merged events

            • (eventType, msg): void

            • Parameters

              • eventType: string
              • msg: T

              Returns void

        Returns (() => void)

        Unsubscribe function for all subscriptions

          • (): void

          • Returns void

  • stateMachine: (<TState, T>(initialState, transitions) => {
        get state(): TState;
        unsubscribe: (() => void);
    })
      • <TState, T>(initialState, transitions): {
            get state(): TState;
            unsubscribe: (() => void);
        }

      • Create a state machine that transitions based on events

        Type Parameters

        • TState extends string
        • T = ApiCallback<string>

        Parameters

        • initialState: TState

          The initial state

        • transitions: Record<TState, Record<string, ((msg) => TState)>>

          Object mapping states to event handlers

        Returns {
            get state(): TState;
            unsubscribe: (() => void);
        }

        Object with current state and unsubscribe function

        • get state(): TState
        • unsubscribe: (() => void)
            • (): void

            • Returns void

  • request: (<TRequest, TResponse>(requestEvent, responseEvent, request, timeout?) => Promise<TResponse>)
      • <TRequest, TResponse>(requestEvent, responseEvent, request, timeout?): Promise<TResponse>

      • Utility to create a promise that can be resolved by publishing an event

        Type Parameters

        • TRequest = any
        • TResponse = ApiCallback<string>

        Parameters

        • requestEvent: string

          Event type to publish the request

        • responseEvent: string

          Event type to wait for the response

        • request: TRequest

          The request data to publish

        • Optional timeout: number

          Optional timeout in milliseconds

        Returns Promise<TResponse>

        Promise that resolves with the response

  • eventIterator: (<T>(eventType) => AsyncIterableIterator<T>)
      • <T>(eventType): AsyncIterableIterator<T>

      • Create an async iterator for events

        Type Parameters

        • T = ApiCallback<string>

        Parameters

        • eventType: string

          The event type to iterate

        Returns AsyncIterableIterator<T>

        Async iterator for use with for-await-of

Settings

Member Visibility

Theme