All APIs to create custom Subscribers are deprecated or internal

[ajafff]

Lately I've been writing some custom operators. v7 makes that unreasonably hard (or rather impossible) by deprecating APIs that IMO are needed.

As an example, consider writing a custom toPromise similar to firstValueFrom, but that never settles the Promise if the Observable doesn't emit a value before completing.

// please only use this code if you know what you are doing. Promises that never settle can cause hard-to-debug issues
export function toPromise<T>(obs$: Observable<T>): Promise<T> {
    return new Promise<T>((resolve, reject) => {
        const subscriber = new Subscriber<T>({ // new Subscriber is deprecated
            next: (v: T) => {
                subscriber.unsubscribe();
                resolve(v);
            },
            error: reject,
            complete() {
            }
        });
        obs$.subscribe(subscriber);
    });
}

Here I need to create a Subscriber up-front because next could be called before subscribe returns the Subscription. But now my IDE/linter tells me that the constructor of Subscriber is deprecated and considered an internal implementation detail.
So what's an appropriate replacement? I tried SafeSubscriber, but that is not exported at all.

I could copy/re-implement the Subscriber class, but I'd prefer not to.

---

Writing custom operators: Let's assume I need to execute some code before AND after next is called, e.g. for performance measurements, instrumentation or whatever.
Taking inspiration from the v7 operator rewrite, I would write it like this:

export function measureExecutionTime<T>(measureAndReport: (work: () => void) => void): MonoTypeOperatorFunction<T> {
  return (source$) => new Observable<T>((subscriber) => {
    source$.subscribe(new OperatorSubscriber<T>(
      subscriber,
      (v: T) => measureAndReport(() => subscriber.next(v)),
    ));
  });
}

Unfortunately OperatorSubscriber is not exported from the public API. The discussion in #5836 about exporting it never had a conclusion.

So let's go back to the v6 approach of writing custom operators: subclassing Subscriber

export function measureExecutionTime<T>(measureAndReport: (work: () => void) => void): MonoTypeOperatorFunction<T> {
  return (source$) => new Observable<T>((subscriber) => {
    source$.subscribe(new MeasureExecutionTimeSubscriber(subscriber, measureAndReport));
  });
}

class MeasureExecutionTimeSubscriber<T> extends Subscriber<T> {
  constructor(destination: Subscriber<T>, private measureAndReport: (work: () => void) => void) {
    super(destination); // This signature is deprecated. eslint-plugin-deprecation currently doesn't report it, but still
  }
  
  public _next(v: T): void {
    this.measureAndReport(() => super._next(v));
  }
}

And now I'm back at the start. The construct signature of Subscriber is deprecated and will be made internal in v8. So what's the supported way of doing this?

I considered using an Observer instead of Subscriber, but that doesn't work well if the consumer unsubscribes while the source is still emitting values synchronously:

export function measureExecutionTime<T>(measureAndReport: (work: () => void) => void): MonoTypeOperatorFunction<T> {
  return (source$) => new Observable<T>((subscriber) => {
    // don't do this. it unsubscribes from the source at earlies when subscribe returns. 
    // if subscriber unsubscribes after the first synchronous notification, source will still complete it's synchronous work until the end, but no one is listening any more
    return source$.subscribe({
      next: (v) => measureAndReport(() => subscriber.next(v)),
      error: (e) => subscriber.error(e),
      complete: () => subscriber.complete(),
    });
  });
}

[benlesh]

It's definitely on our to-do list to think about a way to "productize" the OperatorSubscriber or something like it. Right now it's a little optimized for size and not readability, and we wanted to give the whole concept time to simmer before hastily exporting it.