observable.ts

export type Listener<T> = (value: T) => void;

export type OperatorFunction<T, V> = (
  oberver: IObservable<T>
) => IObservable<V>;

export interface IObservable<T> {
  subscribe(listner: Listener<T>): () => void;
}

export interface Subscriber<T> {
  emit(value: T): void;
}

abstract class AObservable<T> implements IObservable<T> {
  protected listeners: Listener<T>[];

  subscribe(cb: (value: T) => void) {
    this.listeners.push(cb);
    return () => {
      this.listeners = this.listeners.filter((l) => l !== cb);
    };
  }
}

export class Observable<T> extends AObservable<T> {
  constructor(cb: (subscriber: Subscriber<T>) => void) {
    super();

    cb({
      emit: (value: T) => {
        for (const listener of this.listeners) {
          listener(value);
        }
      },
    });
  }
}

export class Subject<T> extends AObservable<T> implements Subscriber<T> {
  emit(value: T) {
    for (const listener of this.listeners) {
      listener(value);
    }
  }
}