@theia/core
Version:
Theia is a cloud & desktop IDE framework implemented in TypeScript.
116 lines • 4.53 kB
TypeScript
import { Disposable, DisposableGroup } from './disposable';
import { MaybePromise } from './types';
/**
* Represents a typed event.
*/
export interface Event<T> {
/**
*
* @param listener The listener function will be call when the event happens.
* @param thisArgs The 'this' which will be used when calling the event listener.
* @param disposables An array to which a {{IDisposable}} will be added.
* @return a disposable to remove the listener again.
*/
(listener: (e: T) => any, thisArgs?: any, disposables?: DisposableGroup): Disposable;
}
export declare namespace Event {
function getMaxListeners(event: Event<unknown>): number;
function setMaxListeners<N extends number>(event: Event<unknown>, maxListeners: N): N;
function addMaxListeners(event: Event<unknown>, add: number): number;
const None: Event<any>;
/**
* Given an event, returns another event which only fires once.
*/
function once<T>(event: Event<T>): Event<T>;
function toPromise<T>(event: Event<T>): Promise<T>;
/**
* Given an event and a `map` function, returns another event which maps each element
* through the mapping function.
*/
function map<I, O>(event: Event<I>, mapFunc: (i: I) => O): Event<O>;
/**
* Given a collection of events, returns a single event which emits whenever any of the provided events emit.
*/
function any<T>(...events: Event<T>[]): Event<T>;
function any(...events: Event<any>[]): Event<void>;
}
declare type Callback = (...args: any[]) => any;
declare class CallbackList implements Iterable<Callback> {
private _callbacks;
private _contexts;
get length(): number;
add(callback: Function, context?: any, bucket?: Disposable[]): void;
remove(callback: Function, context?: any): void;
[Symbol.iterator](): IterableIterator<(...args: any[]) => any>;
invoke(...args: any[]): any[];
isEmpty(): boolean;
dispose(): void;
}
export interface EmitterOptions {
onFirstListenerAdd?: Function;
onLastListenerRemove?: Function;
}
export declare class Emitter<T = any> {
private _options?;
private static LEAK_WARNING_THRESHHOLD;
private static _noop;
private _event;
protected _callbacks: CallbackList | undefined;
private _disposed;
private _leakingStacks;
private _leakWarnCountdown;
constructor(_options?: EmitterOptions | undefined);
/**
* For the public to allow to subscribe
* to events from this Emitter
*/
get event(): Event<T>;
protected checkMaxListeners(maxListeners: number): (() => void) | undefined;
protected pushLeakingStack(): () => void;
protected popLeakingStack(stack: string): void;
/**
* To be kept private to fire an event to
* subscribers
*/
fire(event: T): any;
/**
* Process each listener one by one.
* Return `false` to stop iterating over the listeners, `true` to continue.
*/
sequence(processor: (listener: (e: T) => any) => MaybePromise<boolean>): Promise<void>;
dispose(): void;
}
export declare type WaitUntilData<T> = Omit<T, 'waitUntil' | 'token'>;
export interface WaitUntilEvent {
/**
* A cancellation token.
*/
token: CancellationToken;
/**
* Allows to pause the event loop until the provided thenable resolved.
*
* *Note:* It can only be called during event dispatch and not in an asynchronous manner
*
* @param thenable A thenable that delays execution.
*/
waitUntil(thenable: Promise<any>): void;
}
export declare namespace WaitUntilEvent {
/**
* Fire all listeners in the same tick.
*
* Use `AsyncEmitter.fire` to fire listeners async one after another.
*/
function fire<T extends WaitUntilEvent>(emitter: Emitter<T>, event: WaitUntilData<T>, timeout?: number, token?: CancellationToken): Promise<void>;
}
import { CancellationToken } from './cancellation';
export declare class AsyncEmitter<T extends WaitUntilEvent> extends Emitter<T> {
protected deliveryQueue: Promise<void> | undefined;
/**
* Fire listeners async one after another.
*/
fire(event: WaitUntilData<T>, token?: CancellationToken, promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>): Promise<void>;
protected deliver(listeners: Callback[], event: WaitUntilData<T>, token: CancellationToken, promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>): Promise<void>;
}
export {};
//# sourceMappingURL=event.d.ts.map