Spyon Observable - TypeScript

Introduction

Spyon Observable is a powerful tool for debugging complex asynchronous TypeScript applications. It allows you to spy on observables, which are a type of object that represents a stream of values that can be observed over time. By spying on observables, you can see what values are being emitted, when they are being emitted, and how they are being transformed by operators.

Installation

To install Spyon Observable, you will need to use npm or yarn. Open your command line and run the following command:

npm install spyon-observable --save-dev

or

yarn add spyon-observable --dev

Usage

To start using Spyon Observable, you will need to import it into your TypeScript code:

import { spied } from 'spyon-observable';

Next, you will need to create a new instance of the spied observable:

const myObservable$ = spied(someObservable$);

Now you can start spying on this observable. For example, you can subscribe to it and log the emitted values:

myObservable$.subscribe(value => console.log(`Value emitted: ${value}`));

You can also spy on each operator that is applied to the observable. For example, you can spy on the map operator like this:

myObservable$.pipe(
  map(value => value * 2)
).subscribe(value => console.log(`Value emitted: ${value}`));

Features

Spyon Observable provides several features for debugging observables:

Subscribe

You can subscribe to the spied observable just like any other observable. When you subscribe to the spied observable, you will receive the same values that are emitted by the original observable.

myObservable$.subscribe(value => console.log(`Value emitted: ${value}`));

Spy on Operators

You can spy on each operator that is applied to the observable. This allows you to see how the values are being transformed and filtered by each operator.

myObservable$.pipe(
  map(value => value * 2)
).subscribe(value => console.log(`Value emitted: ${value}`));

Assert

You can use the assert function to ensure that specific values are emitted by the observable. You can pass a function to the assert function that will be called with each emitted value. If the function returns true, the assertion passes. If it returns false, the assertion fails.

myObservable$.assert(value => value > 0);

Catch

You can use the catch function to catch any errors that are thrown by the observable. You can pass a function to the catch function that will be called with the error object that was thrown.

myObservable$
  .pipe(
    map(value => {
      if (value === 0) {
        throw new Error('Value cannot be zero');
      }
      return value;
    })
  )
  .catch(error => console.log(`Error caught: ${error.message}`))
  .subscribe(value => console.log(`Value emitted: ${value}`));

Conclusion

Spyon Observable is a powerful tool for debugging observables in TypeScript applications. It provides several features that allow you to spy on the emitted values, assert specific values, catch errors, and spy on each operator that is applied to the observable. With Spyon Observable, you can easily debug complex asynchronous code and gain a better understanding of how your observables are working.