Improve type inference with zen-observable

spec-dtslint/helpers.ts

@@ -32,3 +32,35 @@ export const g$ = of(new G());
 export const h$ = of(new H());
 export const i$ = of(new I());
 export const j$ = of(new J());
+
+interface Subscription {
+  closed: boolean;
+  unsubscribe(): void;
+}
+interface SubscriptionObserver<T> {
+  closed: boolean;
+  next(value: T): void;
+  error(errorValue: any): void;
+  complete(): void;
+}
+type Subscriber<T> = (observer: SubscriptionObserver<T>) => void | (() => void) | Subscription;
+
+interface Observer<T> {
+  start?(subscription: Subscription): any;
+  next?(value: T): void;
+  error?(errorValue: any): void;
+  complete?(): void;
+}
+
+export declare class CompatObservable<T> {
+  constructor(subscriber: Subscriber<T>);
+
+  subscribe(observer: Observer<T>): Subscription;
+  subscribe(
+      onNext: (value: T) => void,
+      onError?: (error: any) => void,
+      onComplete?: () => void,
+  ): Subscription;
+
+  [Symbol.observable](): CompatObservable<T>;
+}

spec-dtslint/types-spec.ts

@@ -7,7 +7,7 @@ import {
   Head,
   Tail
 } from 'rxjs';
-import { A, B, C } from './helpers';
+import { A, B, C, CompatObservable } from './helpers';
 
 describe('ObservedValueOf', () => {
   it('should infer from an observable', () => {
@@ -24,6 +24,11 @@ describe('ObservedValueOf', () => {
     let explicit: ObservedValueOf<Promise<A>>;
     let inferred = explicit!; // $ExpectType A
   });
+
+  it('should infer from an compatible observable', () => {
+    let explicit: ObservedValueOf<CompatObservable<A>>;
+    const inferred = explicit!; // $ExpectType A
+  });
 });
 
 describe('ObservedUnionFromArray', () => {

src/internal/types.ts

@@ -97,6 +97,11 @@ export interface Subscribable<T> {
   subscribe(observer: Partial<Observer<T>>): Unsubscribable;
 }
 
+export interface InteropSubscribable<T> {
+  subscribe(observer: Partial<Observer<T>>): Unsubscribable;
+  subscribe(onNext?: (value: T) => void, onError?: (error: any) => void, onComplete?: () => void): Subscription;
+}
+
 /**
  * Valid types that can be converted to observables.
  */
@@ -118,7 +123,7 @@ export type ObservableLike<T> = InteropObservable<T>;
  * An object that implements the `Symbol.observable` interface.
  */
 export interface InteropObservable<T> {
-  [Symbol.observable]: () => Subscribable<T>;
+  [Symbol.observable]: () => Subscribable<T> | InteropSubscribable<T>;
 }
 
 /* NOTIFICATIONS */