Class Bus<EventType>

constructor

• new Bus<EventType>(): Bus<EventType>

• Type Parameters

  • EventType

  Returns Bus<EventType>

errors

`bus.errors.subscribe(ex => { console.error(ex) })`
Copy

resets

filter

• filter<MatchType>(matcher, fn): Subscription

• Run a function synchronously for all runtime events, after guards, and prior to spies and listeners. A filter may modify, or replace an event. However the filter must return an event, or that event will not be seen by spies or listeners, and it will be as if the event was never triggered. This is what is meant to 'filter' out events. Throwing an exception will raise to the triggerer, but not terminate the filter.

  Type Parameters

  • MatchType = EventType

  Parameters

  • matcher: Matcher<EventType, MatchType>
  • fn: ((item) => undefined | null | EventType)
    • • (item): undefined | null | EventType

      • Parameters

        • item: MatchType

        Returns undefined | null | EventType

  Returns Subscription

  A subscription that can be used to deactivate the filter.

guard

• guard<MatchType>(matcher, fn): Subscription

• Run a function synchronously for all runtime events, prior to all filters, spies and listeners. Throwing an exception will raise to the triggerer, but not terminate the guard.

  Type Parameters

  • MatchType = EventType

  Parameters

  • matcher: Matcher<EventType, MatchType>
  • fn: ((item) => void)
    • • (item): void

      • Parameters

        • item: MatchType

        Returns void

  Returns Subscription

  A subscription that can be used to deactivate the guard.

listen

• listen<HandlerReturnType, MatchType>(matcher, handler, observer?): Subscription & ActivityTracked

• Assigns a side-effect producing function to matching events in Concurrency Mode "Immediate". Newly returned effects are begun immediately, and so may complete in any order (ala mergeMap), or consume resources unboundedly.

  Type Parameters

  • HandlerReturnType
  • MatchType = EventType

  Parameters

  • matcher: Matcher<EventType, MatchType>

    A predicate run upon every event on the bus. The handler function is only executed if the predicate returns true. If the matcher provides a type guard, the handler will see its events as narrowed to that type.
  • handler: EventHandler<MatchType, HandlerReturnType>

    The side-effect producing function which will "Return The Work", as an ObservableInput (A Promise, Observable, or async generator)
  • Optional observer: EffectObserver<HandlerReturnType>

    An EffectObserver which provides functions to be called upon notifications of the handler

  Returns Subscription & ActivityTracked

  A Subscription that can be used to unsubscribe the listener from future events. If the handler returned an Observable of work, any in-progress work will be canceled upon unsubscribe().

  Summary

  

listenBlocking

• listenBlocking<HandlerReturnType, MatchType>(matcher, handler, observer?): Subscription & ActivityTracked

• Assigns a side-effect producing function to matching events in Concurrency Mode "Blocking" (aka singleton). A new effect is not begun if one is in progress. (ala exhaustMap).

  Type Parameters

  • HandlerReturnType
  • MatchType = EventType

  Parameters

  • matcher: Matcher<EventType, MatchType>

    A predicate run upon every event on the bus. The handler function is only executed if the predicate returns true. If the matcher provides a type guard, the handler will see its events as narrowed to that type.
  • handler: EventHandler<MatchType, HandlerReturnType>

    The side-effect producing function which will "Return The Work", as an ObservableInput (A Promise, Observable, or async generator)
  • Optional observer: EffectObserver<HandlerReturnType>

    An EffectObserver which provides functions to be called upon notifications of the handler

  Returns Subscription & ActivityTracked

  A Subscription that can be used to unsubscribe the listener from future events. If the handler returned an Observable of work, any in-progress work will be canceled upon unsubscribe().

  Summary

  

listenQueueing

• listenQueueing<HandlerReturnType, MatchType>(matcher, handler, observer?): Subscription & ActivityTracked

• Assigns a side-effect producing function to matching events in Concurrency Mode "Queueing". Newly returned effects are enqueued and always complete in the order they were triggered (ala concatMap).

  Type Parameters

  • HandlerReturnType
  • MatchType = EventType

  Parameters

  • matcher: Matcher<EventType, MatchType>

    A predicate run upon every event on the bus. The handler function is only executed if the predicate returns true. If the matcher provides a type guard, the handler will see its events as narrowed to that type.
  • handler: EventHandler<MatchType, HandlerReturnType>

    The side-effect producing function which will "Return The Work", as an ObservableInput (A Promise, Observable, or async generator)
  • Optional observer: EffectObserver<HandlerReturnType>

    An EffectObserver which provides functions to be called upon notifications of the handler

  Returns Subscription & ActivityTracked

  A Subscription that can be used to unsubscribe the listener from future events. If the handler returned an Observable of work, any in-progress work will be canceled upon unsubscribe().

  Summary

  

listenSwitching

• listenSwitching<HandlerReturnType, MatchType>(matcher, handler, observer?): Subscription & ActivityTracked

• Assigns a side-effect producing function to matching events in Concurrency Mode "Switching". Any existing effect is canceled (if it is an Observable, not a Promise) before the new effect is begun (ala switchMap).

  Type Parameters

  • HandlerReturnType
  • MatchType = EventType

  Parameters

  • matcher: Matcher<EventType, MatchType>

    A predicate run upon every event on the bus. The handler function is only executed if the predicate returns true. If the matcher provides a type guard, the handler will see its events as narrowed to that type.
  • handler: EventHandler<MatchType, HandlerReturnType>

    The side-effect producing function which will "Return The Work", as an ObservableInput (A Promise, Observable, or async generator)
  • Optional observer: EffectObserver<HandlerReturnType>

    An EffectObserver which provides functions to be called upon notifications of the handler

  Returns Subscription & ActivityTracked

  A Subscription that can be used to unsubscribe the listener from future events. If the handler returned an Observable of work, any in-progress work will be canceled upon unsubscribe().

  Summary

  

listenToggling

• listenToggling<HandlerReturnType, MatchType>(matcher, handler, observer?): Subscription & ActivityTracked

• Triggers effects upon matching events, using a Toggling (gate) Concurrency Strategy. A new effect is not begun if one is in progress, and the existing effect is canceled.

  Type Parameters

  • HandlerReturnType
  • MatchType = EventType

  Parameters

  • matcher: Matcher<EventType, MatchType>

    A predicate run upon every event on the bus. The handler function is only executed if the predicate returns true. If the matcher provides a type guard, the handler will see its events as narrowed to that type.
  • handler: EventHandler<MatchType, HandlerReturnType>

    Called for each matching event, returns an ObservableInput (an Iterable,Promise,Observable)
  • Optional observer: EffectObserver<HandlerReturnType>

    An EffectObserver which provides functions to be called upon notifications of the handler

  Returns Subscription & ActivityTracked

  A subscription that can be used to unsubscribe the listener, thereby canceling work in progress.

  Summary

  

next

• next(item): void

• Alias for Bus.trigger

  Parameters

  • item: EventType

  Returns void

nextEvent

• nextEvent<MatchType>(matcher): Promise<MatchType>

• Returns a Promise for the first event for which the predicate returns true. The returned Promise will be rejected upon a bus.reset. If the predicate is a type guard, the returned Promise will be narrowed to the matching type.

  Type Parameters

  • MatchType = EventType

  Parameters

  • matcher: Matcher<EventType, MatchType>

    A predicate to select the first event for which it returns true.

  Returns Promise<MatchType>

observeAll

• observeAll<HandlerReturnType>(): EffectObserver<HandlerReturnType>

• Creates an EffectObserver which triggers each value from the handler back onto the bus. Use this when the listener returns items suitable for putting directly onto the bus.

  Type Parameters

  • HandlerReturnType

  Returns EffectObserver<HandlerReturnType>

observeWith

• observeWith<HandlerReturnType>(mapper): PartialObserver<HandlerReturnType> & SubscriptionObserver

• Creates an EffectObserver which triggers the handlers' lifecycle events, after running through a mapping function. Use this when the listener's values are not compatible with the bus, or to capture lifecycle events.

  Type Parameters

  • HandlerReturnType

  Parameters

  • mapper: Partial<Record<ObserverKey, MapFn<HandlerReturnType, EventType>>>

  Returns PartialObserver<HandlerReturnType> & SubscriptionObserver

  Example: ``` bus.listen( isSearchRequest, () => from([{ result: 'foo' }]), bus.observeWith({ subscribe: () => ({ type: 'search/started' }) }) ); ```

query

• query<MatchType>(matcher): Observable<EventType>

• Returns an Observable of events for which the predicate returns true. The returned Observable completes upon a bus.reset. If the predicate is a type guard, the returned Observable will be narrowed to the matching type.

  Type Parameters

  • MatchType = EventType

  Parameters

  • matcher: Matcher<EventType, MatchType>

    A predicate to select events for which it returns true.

  Returns Observable<EventType>

  See

  Bus.reset

  Example

  `bus.query(() => true).subscribe(console.log)`
  Copy

reset

• reset(): void

• Unsubscribes all guards, filters, spies and listeners, canceling handlings-in-progress if they were returned Observables, and reverting the bus to how it was when newly constructed.

  Returns void

spy

• spy(fn): Subscription

• Run a function (synchronously) for all runtime events, prior to all listeners. Throwing an exception will terminate the spy.

  Parameters

  • fn: ((item) => void)
    • • (item): void

      • Parameters

        • item: EventType

        Returns void

  Returns Subscription

  A subscription that can be used to deactivate the spy.

trigger

• trigger(item): void

• Puts an event onto the bus, firing any listeners whose predicate returns true. Events go first through guards, then filters, then spies, then listeners.

  Parameters

  • item: EventType

    The item to send to listeners, once it clears guards, filters, and spies.

  Returns void

  Throws

  if a guard, or filter throws an exception. Listener exceptions or errors do not throw, but appear on bus.errors, and terminate that listener.

  See

  Bus.errors Bus.filter Bus.guard Bus.spy Bus.listen