UNPKG

@theia/core

Version:

Theia is a cloud & desktop IDE framework implemented in TypeScript.

116 lines 4.53 kB
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