exhaustMap equivalent

Hi there
I am new to xstream and I want to use something like exhaustMap operation.
I can not figure out what to do given the available operators (anything like flattenFirst maybe).
What do I do?

[xtianjohns]

Do you want to do something like exhaustMap, @MidnightWonderer? Which parts do you want to keep?

The following should be an acceptable operator implementing only exhaust.

import xs, { Stream } from 'xstream';
import flattenSequentially from 'xstream/extra/flattenSequentially';

function exhaust<T>( source ): Stream<T> {
  /* Initialize listening status to false. */
  let listening: boolean = false;
  
  /**
   * Project the source into a stream of streams.
   * Each will have a value or be empty.
   */
  const projected = source.map( element => xs.of( element ) ).map( project );
  
  function project( inner ) {
    /* We're not listening, project the element. */
    if ( !listening ) {
      /* Toggle listening status. */
      listening = true;
  
      /* When that stream ends, set listening status to false. */
      inner.addListener({
        complete: () => {
          listening = false;
        },
      });

      /* Return the inner stream. */
      return inner;
    }
    
    /* We're already listening, emit nothing. */
    return xs.empty();
  }

  /* Flatten the result streams into a single stream. */
  return projected.compose( flattenSequentially );
}

You would use this operator as @staltz says, using compose.

/* Create a source. */
const source = xs.periodic( 100 );

/* Use the operator. */
source.compose( exhaust );

If you also wanted the projection capabilities in exhaustMap, you’d need to modify the operator to support a selector.

function exhaustMap( selector ) {
  return function exhaust<T>( source ): Stream<T> {
    // ...
    /**
     * Project the source into a stream of streams.
     * Each will have a value or be empty.
     */
    const projected = source.map( selector ).map( project );
  
    function project( element ) {
      // ...
    }
    // ...
  }
}

And you can use this operator by providing a selector. Here is a bin.

import delay from 'xstream/extra/delay';
const source = xs.periodic( 1000 );

const selector = () => xs.from( [ 1, 2, 3] ).compose( delay( 1000 ) );

source.compose( exhaustMap( selector ) );

Does this help you implement your feature?

[midnight-wonderer]

Thank you both for the clarification.