Variable EventBusStateConst

Type declaration

• waitForOrGetState: (<T>(eventType, options) => Promise<T>)

  • • <T>(eventType, options): Promise<T>

    • Wait for an event OR get the current state if the event already happened This prevents race conditions where events fire before subscription

      Type Parameters

      • T = ApiCallback<string>

      Parameters

      • eventType: string

        The event type to wait for
      • options: StateAwareOptions<T>

        Options for state fetching and transformation

      Returns Promise<T>

      Promise that resolves with either the event data or current state

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

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

    • Subscribe to events with initial state, ensuring no events are missed

      Type Parameters

      • T = ApiCallback<string>

      Parameters

      • eventType: string

        The event type to subscribe to
      • callback: EventCallback<T>

        Callback for state updates
      • options: StateAwareOptions<T>

        Options for initial state fetching

      Returns (() => void)

      Unsubscribe function

      • • (): void

        • Returns void

• createStatefulEventStream: (<T>(eventType, stateApi) => {
      get state(): undefined | T;
      getState(): Promise<T>;
      subscribe(callback): (() => void);
      refresh(): Promise<T>;
  })

  • • <T>(eventType, stateApi): {
          get state(): undefined | T;
          getState(): Promise<T>;
          subscribe(callback): (() => void);
          refresh(): Promise<T>;
      }

    • Create a state-synchronized event stream that combines initial state with events

      Type Parameters

      • T = any

      Parameters

      • eventType: string

        The event type for updates
      • stateApi: string | (() => Promise<T>)

        API endpoint or function to fetch current state

      Returns {
          get state(): undefined | T;
          getState(): Promise<T>;
          subscribe(callback): (() => void);
          refresh(): Promise<T>;
      }

      Object with subscribe method and current state getter

      • get state(): undefined | T

        Get current state synchronously (may be undefined if not loaded)

      • getState:function

        • getState(): Promise<T>

        • Get current state asynchronously (waits for initial load)

          Returns Promise<T>

      • subscribe:function

        • subscribe(callback): (() => void)

        • Subscribe to state changes (includes initial state)

          Parameters

          • callback: ((state) => void)
            • • (state): void

              • Parameters

                • state: T

                Returns void

          Returns (() => void)

          • • (): void

            • Returns void

      • refresh:function

        • refresh(): Promise<T>

        • Refresh state from API

          Returns Promise<T>

• waitForAllWithState: {
      <T>(eventTypes, options): Promise<T>;
      <T>(eventType, options): Promise<T>;
  }

  • • <T>(eventTypes, options): Promise<T>

    • Wait for multiple events with shared state checking Checks global state once to see if all conditions are already met

      Type Parameters

      • T = ApiCallback<string>

      Parameters

      • eventTypes: string[]

        Array of event types to wait for
      • options: StateAwareOptions<T>

        Shared state checking options

      Returns Promise<T>

      Promise that resolves when all events have occurred or state is ready
    • <T>(eventType, options): Promise<T>

    • Wait for a single event with state checking (convenience overload)

      Type Parameters

      • T = ApiCallback<string>

      Parameters

      • eventType: string

        Single event type to wait for
      • options: StateAwareOptions<T>

        State checking options

      Returns Promise<T>

      Promise that resolves when event occurs or state is ready

• createResilientEventHandler: (<T>(eventType, handler, recoveryStrategy) => (() => void))

  • • <T>(eventType, handler, recoveryStrategy): (() => void)

    • Create a resilient event handler that can recover from missed events

      Type Parameters

      • T = ApiCallback<string>

      Parameters

      • eventType: string

        Event type to handle
      • handler: ((data) => void | Promise<void>)

        Event handler function

        • • (data): void | Promise<void>

          • Parameters

            • data: T

            Returns void | Promise<void>

      • recoveryStrategy: {
            fetchMissedEvents: (() => Promise<T[]> | Promise<T>);
            checkInterval?: number;
            deduplicateById?: ((event) => string);
        }

        Strategy for recovering missed events

        • fetchMissedEvents: (() => Promise<T[]> | Promise<T>)

          API to fetch missed events or current state

          • • (): Promise<T[]> | Promise<T>

            • Returns Promise<T[]> | Promise<T>

        • Optional checkInterval?: number

          How often to check for missed events (ms)

        • Optional deduplicateById?: ((event) => string)

          Whether to deduplicate events by ID

          • • (event): string

            • Parameters

              • event: T

              Returns string

      Returns (() => void)

      • • (): void

        • Returns void

• createConnectionStateManager: (<T>(config) => ConnectionStateManager<T>)

  • • <T>(config): ConnectionStateManager<T>

    • Create a connection state manager that handles online/offline scenarios

      Type Parameters

      • T = any

      Parameters

      • config: {
            connectEvent: string;
            disconnectEvent: string;
            fetchInitialState: (() => Promise<T>);
            errorEvent?: string;
            dataEvent?: string;
            reconnectDelay?: number;
        }

        • connectEvent: string

        • disconnectEvent: string

        • fetchInitialState: (() => Promise<T>)

          • • (): Promise<T>

            • Returns Promise<T>

        • Optional errorEvent?: string

        • Optional dataEvent?: string

        • Optional reconnectDelay?: number

      Returns ConnectionStateManager<T>