Skip to main content

Type Alias: Observable<T>

Observable<T> = RxjsObservable<SubscribeValueWrapper<T>>

Observable is a custom type alias for an RxJS Observable that emits objects containing both the new value and the previous value whenever a subscribed state field changes.

Type Parameters​

T​

T

Remarks​

Think of an Observable as live news feed or a radio station that constantly broadcasts updates over time. When you subscribe to an Observable, you're essentially tuning in to receive these updates.

Each time the underlying data changes, the Observable sends out a "news bulletin" in the form of a wrapped object. This object always contains:

  • newValue: The latest data that has just been updated.
  • oldValue: The previous data before the update occurred (if available).

This design makes it easy to compare what changed without needing to manually store previous state.

Use Cases:

  • Real-Time UI Updates: Automatically refresh parts of your application UI when data changes.
  • Logging and Auditing: Track changes over time by logging both the old and new values.
  • Business Logic: Trigger actions or side effects (e.g., notifications, recalculations) whenever important data updates occur.

Example​

// Imagine you have a counter that updates over time.
const counterObservable: Observable<number> = getObservableForField('counter');

// Subscribe to the observable to listen for changes:
counterObservable.subscribe(({ newValue, oldValue }) => {
  console.log(`The counter changed from ${oldValue} to ${newValue}`);
  // Here, you could update the UI, perform a calculation, or trigger other actions.
});

In this example, every time the counter's value changes, you receive both the new and previous values,
allowing you to react appropriately to the update.

Overall, the Observable type is a core part of a reactive programming model, providing a clean and
consistent way to handle data changes over time.