mirror of
https://github.com/microsoft/vscode.git
synced 2026-02-27 05:05:10 +00:00
99 lines
2.9 KiB
TypeScript
99 lines
2.9 KiB
TypeScript
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
|
|
'use strict';
|
|
|
|
import { Event } from 'vscode';
|
|
|
|
export function log(...args: any[]): void {
|
|
console.log.apply(console, ['git:', ...args]);
|
|
}
|
|
|
|
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);
|
|
|
|
export function mapEvent<I, O>(event: Event<I>, map: (i: I) => O): Event<O> {
|
|
return (listener, thisArgs = null, disposables?) => event(i => listener.call(thisArgs, map(i)), null, disposables);
|
|
}
|
|
|
|
export function filterEvent<T>(event: Event<T>, filter: (e: T) => boolean): Event<T> {
|
|
return (listener, thisArgs = null, disposables?) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables);
|
|
}
|
|
|
|
export function anyEvent<T>(...events: Event<T>[]): Event<T> {
|
|
return (listener, thisArgs = null, disposables?) => combinedDisposable(events.map(event => event(i => listener.call(thisArgs, i), disposables)));
|
|
}
|
|
|
|
export function done<T>(promise: Promise<T>): Promise<void> {
|
|
return promise.then<void>(() => void 0, () => void 0);
|
|
}
|
|
|
|
export function once<T>(event: Event<T>): Event<T> {
|
|
return (listener, thisArgs = null, disposables?) => {
|
|
const result = event(e => {
|
|
result.dispose();
|
|
return listener.call(thisArgs, e);
|
|
}, null, disposables);
|
|
|
|
return result;
|
|
};
|
|
}
|
|
|
|
export function eventToPromise<T>(event: Event<T>): Promise<T> {
|
|
return new Promise(c => once(event)(c));
|
|
}
|
|
|
|
// TODO@Joao: replace with Object.assign
|
|
export function assign<T>(destination: T, ...sources: any[]): T {
|
|
for (const source of sources) {
|
|
Object.keys(source).forEach(key => destination[key] = source[key]);
|
|
}
|
|
|
|
return destination;
|
|
}
|
|
|
|
export function uniqBy<T>(arr: T[], fn: (el: T) => string): T[] {
|
|
const seen = Object.create(null);
|
|
|
|
return arr.filter(el => {
|
|
const key = fn(el);
|
|
|
|
if (seen[key]) {
|
|
return false;
|
|
}
|
|
|
|
seen[key] = true;
|
|
return true;
|
|
});
|
|
}
|
|
|
|
export function groupBy<T>(arr: T[], fn: (el: T) => string): { [key: string]: T[] } {
|
|
return arr.reduce((result, el) => {
|
|
const key = fn(el);
|
|
result[key] = [...(result[key] || []), el];
|
|
return result;
|
|
}, Object.create(null));
|
|
}
|
|
|
|
export function denodeify<R>(fn: Function): (...args) => Promise<R> {
|
|
return (...args) => new Promise((c, e) => fn(...args, (err, r) => err ? e(err) : c(r)));
|
|
}
|