export type PromiseType<T> = T extends Promise<infer U> ? U : T;
export type AsyncReturnType<F extends () => any> = PromiseType<ReturnType<F>>;

export abstract class ExtensiblePromise<T> implements PromiseLike<T> {
	constructor() {
		this.promise = new Promise((resolve, reject) => {
			this._reject = reject;
			this._resolve = resolve;
		});
	}

	readonly promise: Promise<T>;

	protected _resolve: (arg: T) => void;
	protected _reject: (reason?: any) => void;

	then<TResult1 = T, TResult2 = never>(
		onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>,
		onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>
	): Promise<TResult1 | TResult2> {
		return this.promise.then(onfulfilled, onrejected);
	}

	catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult> {
		return this.promise.catch(onrejected);
	}
}

/**
 * A Promise-Like class that can be controlled (resolved/rejected) via a public API
 */
export class ControlledPromise<T> extends ExtensiblePromise<T> {
	resolve(p?: T) { this._resolve(p); }
	reject(e?: any) { this._reject(e); }
}

export const delay = ms => new Promise(res => setTimeout(res, ms))