IPromiseBasedObservable typings improvement

As for now, IPromiseBasedObservable<T> has this definition:

export interface IPromiseBasedObservable<T> {
    value: T;
    state: PromiseState;
    reason: any;
    promise: PromiseLike<T>;
    case<U>(handlers: {pending?: () => U, fulfilled?: (t: T) => U, rejected?: (e: any) => U}): U;
}

I suggest to change that to get stronger types:

interface IPromiseBasedObservablePending {
  state: "pending"
}
interface IPromiseBasedObservableFulfilled<T> {
  state: "fulfilled"
  value: T
}
interface IPromiseBasedObservableRejected {
  state: "rejected"
  value: Error
}
export type IPromiseBasedObservable<T> = (
  IPromiseBasedObservablePending |
  IPromiseBasedObservableFulfilled<T> |
  IPromiseBasedObservableRejected
) & {
  promise: PromiseLike<T>;
  case<U>(handlers: {pending?: () => U, fulfilled?: (t: T) => U, rejected?: (e: Error) => U}): U;
}

After that typescript will force developer to cover all cases of state and gives strict access to value:

function render(v: IPromiseBasedObservable<string>): string {
  return v.value // Property 'value' does not exists on type 'IPromiseBasedObservable<string>'
}

function render(v: IPromiseBasedObservable<string>): string {
    if (v.state === "pending") {
        return "value is pending"
    }
    if (v.state === "rejected") {
        return `value is rejected with: ${v.value.message}` // v.value is Error here
    }
    return `value is: ${v.value}`; // v.value is string here
}

Also I suggest to either:

1. Remove case function from IPromiseBasedObservable
2. Make all handlers required, for each state.

With strictNullChecks enabled it gives proper check for all cases of v.state are covered. It is breaking change and usable only for TS2+, so, it should introduce new major version.

[mweststrate]

Seems like a good improvement @Strate. Feel free to implement|!

[Strate]

Wow, great! Thank you, and sorry for not to be volunteer of this 😦