observable.ts

export type Callback<T extends Array<any> = [], U = void> = (...args: T) => U

export interface Subscriber<T> {
  subscribe(
    value: Callback<[T], any>,
    error?: Callback<[unknown], any>,
    complete?: Callback<[], any>
  ): Unsubscriber
}

export interface Unsubscriber {
  unsubscribe(): void
}

export class Observable<T> implements Subscriber<T> {
  private _setup: Callback<[
    Callback<[T]>, 
    Callback<[any]>, 
    Callback
  ], void | Callback<[], any>>

  constructor(
    setup: Callback<[
      Callback<[T]>,
      Callback<[any]>,
      Callback,
    ], void | Callback<[], any>>
  ) {
    this._setup = setup;
  }

  subscribe(
    valueCallback: Callback<[T]>, 
    errorCallback?: Callback<[unknown]>, 
    completeCallback?: Callback<[], any>,
  ): Unsubscriber {
    let isActive: boolean = true;

    const teardown = this._setup(
      (value: T) => {
        if (isActive) valueCallback(value)
      },
      (error: unknown) => {
        if (!isActive) return;
        if (errorCallback) errorCallback(error);
        isActive = false;
      },
      () => {
        if (!isActive) return;
        if (typeof teardown === 'function') teardown();
        if (completeCallback) completeCallback();
        isActive = false;
      }
    )

    if (!isActive && teardown) {
      teardown()
    } 

    return new Subscription(() => {
      if (teardown) teardown()
      isActive = false
    })
  }
}

export class Subscription implements Unsubscriber {
  constructor(
    public unsubscribe: () => void
  ) {}
}