import { Disposable, Event } from 'vscode';
import { combinedDisposable } from './disposableUtils';
export function fireEvent<T> (event: Event<T>): Event<T> {
  return (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => event(_ => (listener as any).call(thisArgs), null, disposables);
}
export function mapEvent<I, O> (event: Event<I>, map: (i: I) => O): Event<O> {
  return (listener: (e: O) => any, thisArgs?: any, disposables?: Disposable[]) => event(i => listener.call(thisArgs, map(i)), null, disposables);
}
export function filterEvent<T> (event: Event<T>, filter: (e: T) => boolean): Event<T> {
  return (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables);
}
export function anyEvent<T> (...events: Array<Event<T>>): Event<T> {
  return (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => {
    const result = combinedDisposable(events.map(event => event(i => listener.call(thisArgs, i))));
    if (disposables) {
      disposables.push(result);
    }
    return result;
  };
}
export function onceEvent<T> (event: Event<T>): Event<T> {
  return (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => {
    const result = event(e => {
      result.dispose();
      return listener.call(thisArgs, e);
    }, null, disposables);
    return result;
  };
}
export function debounceEvent<T> (event: Event<T>, delay: number): Event<T> {
  return (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => {
    let timer: NodeJS.Timer;
    return event(e => {
      clearTimeout(timer);
      timer = setTimeout(() => listener.call(thisArgs, e), delay);
    }, null, disposables);
  };
}
export async function eventToPromise<T> (event: Event<T>): Promise<T> {
  return await new Promise<T>(resolve => onceEvent(event)(resolve));
}

export interface IDisposable {
  dispose: () => void
}
export function dispose<T extends IDisposable> (disposables: T[]): T[] {
  disposables.forEach(d => d.dispose());
  return [];
}
export function toDisposable (dispose: () => void): IDisposable {
  return { dispose };
}
export function combinedDisposable (disposables: IDisposable[]): IDisposable {
  return toDisposable(() => dispose(disposables));
}
export const EmptyDisposable = toDisposable(() => null);

S FILE DIRECTLY.
# yarn lockfile v1
"@babel/code-fram

import { combinedDisposable } from './disposableUtils';