Allow finalize to not be executed on unsubscription

[yohny]

It wouldd be nice if it was possible to instruct finalize to not execute on unsubscription. Currently finalize is executed when source observable terminates with complete or error and also when its unsubscribed.
Imagine a use case where user clicks trigger other observable, for example to load some data. This is usually handled by switchMaping, so when user clicks again while previous data is loaded, it is cancelled (unsubscribed) and only new data is being loaded. Usually in such case there are some side effects to indicate loading is in progress.

 this.clicks$
      .pipe(
          tap(() => showLoadingSpinner()),
          switchMap((click) =>
             loadData() // loadData() returns observable that loads data
             .pipe(
                finalize(() => hideLoadingSpinner()),  // hide spinner when loading finishes or errors
             )
       )
      .subscribe((data) => {
         // do something with data
      })

in case above the loadingSpinner will be hidden when clicked while data is loading, because switchMap's unsubscription of loaddata() causes finalize callback to be executed. However in this case we dont want that, we want to execute the callback only when loadData() finishes or errors, not when unsubscribed.
Adding optional argument to finalize that would disable callback execution on unsubscription, would be handy.

[demensky]

Something like this?

import { MonoTypeOperatorFunction, tap } from 'rxjs';

function finished<T>(callback: () => void): MonoTypeOperatorFunction<T> {
  return tap({ complete: callback, error: callback });
}

[yohny]

well almost 😄 your solution with tap executes callback on emit and error, while the finalize I want would execute on complete and error

[demensky]

My solution calls a callback when an error or completion occurs. Example.

[yohny]

yes, you are right, your solution achieves what I want, I somehow missed the complete argument

[JeromeDeLeon]

Is there any reason why it couldn't be like the one below? It feels more reactive to me than relying on finalize or tap
Here's a sample playground.

const clickEvent$ = new Subject();

const loadData$ = clickEvent$.pipe(switchMap(() => of(Math.random()).pipe(delay(1000))));

const isLoading$ = merge(
  clickEvent$.pipe(map(() => true)),
  loadData$.pipe(map(() => false)),
).pipe(
  startWith(false),
  distinctUntilChanged(),
);

[yohny]

to clarify - I know that what I want is achievable by other means than finalize, that's not the point - the point is a suggestion to extend finalize so it supports this behavior out of the box

[JoelCodes]

I know that I use finalize for complete, error, or unsubscribe, so if this were to happen to finalize, it would need to be with a second param, e.g. finalize(callback:() => void, suppressUnsubscribe:boolean = false), so that you could call finalize specifically the way you want.

 this.clicks$
      .pipe(
          tap(() => showLoadingSpinner()),
          switchMap((click) =>
             loadData() // loadData() returns observable that loads data
             .pipe(
                finalize(() => hideLoadingSpinner(), true),  // hide spinner when loading finishes or errors
             )
       )
      .subscribe((data) => {
         // do something with data
      })