keyeventstream :thinking:

import { merge, Observable, Observer } from 'rxjs';
import { distinctUntilChanged, filter, scan } from 'rxjs/internal/operators';
import { map } from 'rxjs/operators';
import { unless } from '../shared/operators';

export interface KeyEvent {
  readonly keyCode: number;
}

export const keyEventStream = (
  targetKeys: number[],
  blur$: Observable<any>,
  keyDown$: Observable<KeyEvent>,
  keyUp$: Observable<KeyEvent>,
  isDisabled$: Observable<boolean>,
): Observable<number[]> =>
  new Observable((observer: Observer<number[]>) => {

    const onlyTargetKeys = filter((event: KeyEvent) =>
      targetKeys.includes(event.keyCode),
    );
    
    const calculateNewKeyCombo = scan(
      (
        currentKeyCombo: Set<number>,
      ): Set<number> => currentKeyCombo,
    );

    const keyComboStream = (currentKeyCombo: Set<number>): Observable<number[]> => merge(
      keyDown$.pipe(
        unless(isDisabled$),
        onlyTargetKeys,
        map((event) => currentKeyCombo.add(event.keyCode)),
      ),
      keyUp$.pipe(
        unless(isDisabled$),
        onlyTargetKeys,
        map((event) => currentKeyCombo.delete(event.keyCode)),
      ),
      blur$.pipe(
        map(() => currentKeyCombo.clear()),
      ),
    ).pipe(
      calculateNewKeyCombo,
      distinctUntilChanged(),
      map((newKeyCombo: Set<number>) => [...newKeyCombo]),
    );

    return keyComboStream(new Set<number>()).subscribe(observer);
  });