How to proxy Observable? about comlink HOT 8 CLOSED

import { Remote, proxy, releaseProxy, transferHandlers } from 'comlink'; // v4.4.1
import { Observable, Observer, Subscribable, Subscription } from 'rxjs'; // v7.8.0

transferHandlers.set('observable', {
  canHandle: (value: unknown): value is Observable<unknown> => {
    return value instanceof Observable;
  },
  deserialize: (value: MessagePort) => {
    return new Observable<unknown>((observer) => {
      const remote = transferHandlers.get('proxy')!
        .deserialize(value) as Remote<Subscribable<unknown>>;

      void remote.subscribe(proxy({
        next: (next: unknown) => observer.next(next),
        error: (error: unknown) => observer.error(error),
        complete: () => observer.complete()
      })).then((subscription) => observer.add(() => {
        subscription.unsubscribe();
        remote[releaseProxy]();
      }));
    });
  },
  serialize: (value: Observable<unknown>) => {
    return transferHandlers.get('proxy')!.serialize({
      subscribe: (observer: Remote<Observer<unknown>>) => value.subscribe({
        next: (next: unknown) => void observer.next(next).then(),
        error: (error: unknown) => void observer.error(error).then(),
        complete: () => void observer.complete().then()
      })
    });
  }
});

transferHandlers.set('subscription', {
  canHandle: (value: unknown): value is Subscription => {
    return value instanceof Subscription;
  },
  deserialize: (value: MessagePort) => {
    return new Subscription(() => {
      const remote = transferHandlers.get('proxy')!
        .deserialize(value) as Remote<Subscription>;

      void remote.unsubscribe().then(() => {
        remote[releaseProxy]();
      });
    });
  },
  serialize: (value: Subscription) => {
    return transferHandlers.get('proxy')!.serialize({
      unsubscribe: () => value.unsubscribe()
    });
  }
});

import {
  Observable,
  Subscription,
  PartialObserver,
  from,
  observable,
  Subscribable
} from "rxjs";
import * as comlink from "./comlink";

interface SubscribableNoOverloads<T> {
  subscribe(
    ...observer:
      | [PartialObserver<T> | undefined]
      | [
          ((value: T) => void) | undefined | null,
          ((error: any) => void) | undefined | null,
          (() => void) | undefined | null
        ]
  ): Subscription;
}

// Worker
const apiWorkerSide = {
  foo(): SubscribableNoOverloads<number> & comlink.ProxyValue {
    return comlink.proxyValue(new Observable<number>());
  }
};
comlink.expose(apiWorkerSide, self);

// Main
const proxyObservable = <T>(
  proxy: comlink.ProxyResult<SubscribableNoOverloads<T>>
): Observable<T> =>
  from(({
    [observable]() {
      return this;
    },
    subscribe(observer: PartialObserver<T>): Subscription {
      const subscription = new Subscription();
      proxy.subscribe(comlink.proxyValue(observer)).then(s => {
        subscription.add(s);
      });
      return subscription;
    }
  } as any) as Subscribable<T>);

const proxy = comlink.proxy<typeof apiWorkerSide>(new Worker("worker.js"));
const api = {
  foo(): SubscribableNoOverloads<number> {
    return proxyObservable(proxy.foo());
  }
};