Merge VS Code 1.23.1 (#1520)

src/vs/base/common/event.ts

@@ -14,17 +14,15 @@ import { LinkedList } from 'vs/base/common/linkedList';
  * To an event a function with one or zero parameters
  * can be subscribed. The event is the subscriber function itself.
  */
-interface Event<T> {
+export interface Event<T> {
 	(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;
 }
 
-namespace Event {
+export namespace Event {
 	const _disposable = { dispose() { } };
 	export const None: Event<any> = function () { return _disposable; };
 }
 
-export default Event;
-
 type Listener = [Function, any] | Function;
 
 export interface EmitterOptions {
@@ -163,7 +161,7 @@ export class Emitter<T> {
 
 export class EventMultiplexer<T> implements IDisposable {
 
-	private emitter: Emitter<T>;
+	private readonly emitter: Emitter<T>;
 	private hasListeners = false;
 	private events: { event: Event<T>; listener: IDisposable; }[] = [];
 
@@ -281,7 +279,7 @@ export function debounceEvent<I, O>(event: Event<I>, merger: (last: O, event: I)
 
 	let subscription: IDisposable;
 	let output: O = undefined;
-	let handle: number = undefined;
+	let handle: any = undefined;
 	let numDebouncedCalls = 0;
 
 	const emitter = new Emitter<O>({
@@ -367,6 +365,7 @@ export interface IChainableEvent<T> {
 	map<O>(fn: (i: T) => O): IChainableEvent<O>;
 	forEach(fn: (i: T) => void): IChainableEvent<T>;
 	filter(fn: (e: T) => boolean): IChainableEvent<T>;
+	latch(): IChainableEvent<T>;
 	on(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;
 }
 
@@ -400,6 +399,10 @@ class ChainableEvent<T> implements IChainableEvent<T> {
 		return new ChainableEvent(filterEvent(this._event, fn));
 	}
 
+	latch(): IChainableEvent<T> {
+		return new ChainableEvent(latch(this._event));
+	}
+
 	on(listener: (e: T) => any, thisArgs: any, disposables: IDisposable[]) {
 		return this._event(listener, thisArgs, disposables);
 	}
@@ -536,3 +539,15 @@ export function fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: st
 
 	return result.event;
 }
+
+export function latch<T>(event: Event<T>): Event<T> {
+	let firstCall = true;
+	let cache: T;
+
+	return filterEvent(event, value => {
+		let shouldEmit = firstCall || value !== cache;
+		firstCall = false;
+		cache = value;
+		return shouldEmit;
+	});
+}