font

color_theme

package

API `@deepkit/event`

npm install @deepkit/event

Read App Events for more information about how to use events in your application.

Errors

EventError

Classes

Functions

Types

Classes

export class EventToken<T extends BaseEvent = BaseEvent> {
    /**
     * This is only to get easy the event-type. In reality this property is undefined.
     * e.g. `onHttpRequest(event: typeof onHttpRequest.event) {`
     */
    readonly event: T;
    constructor(public readonly id: string, event?: ClassType<T>);
    listen(callback: EventListenerCallback<EventToken<T>>, order: number = , module?: InjectorModule): EventListener;
}

Defines a new event token that is dispatched in an asynchronous way. This token can be used to listen to events. Per default this has no event data, so use DataEventToken for that.

export class EventTokenSync<T extends BaseEvent = BaseEvent> extends EventToken<T> {
    readonly sync: boolean;
}

Defines a new event token that is dispatched in a synchronous way. It's not possible to subscribe to this event token with async listeners.

const onChange = new EventTokenSync<DataEvent<{change: string}>>('change');

eventDispatcher.listen(onChange, (event) => {
  console.log(event.data.change); // 'hello'
});

eventDispatcher.dispatch(onChange, {change: 'hello'});

export class DataEventToken<T> extends EventToken<SimpleDataEvent<T>> {
}

export class BaseEvent {
    immediatePropagationStopped: boolean;
    defaultPrevented: boolean;
    preventDefault();
    stopImmediatePropagation();
}

export class DataEvent<T> extends BaseEvent implements SimpleDataEvent<T> {
    constructor(public data: T);
}

export class EventDispatcher {
    constructor(public injector: InjectorContext = InjectorContext.forProviders([]));
    registerListener(classType: ClassType, module: InjectorModule): EventListenerRegistered[];
    /**
     * Register a new event listener for given token.
     *
     * order: The lower the order, the sooner the listener is called. Default is 0.
     */
    listen<T extends EventToken<any>>(eventToken: T, callback: EventListenerCallback<T>, order: number = ): EventDispatcherUnsubscribe;
    add(eventToken: EventToken<any>, listener: EventListenerContainerEntry): EventDispatcherUnsubscribe;
    /**
     * Waits for the next event of given token.
     */
    next<T extends EventToken<any>>(eventToken: T): Promise<T[]>;
    getTokens(): EventToken<any>[];
    hasListeners(eventToken: EventToken<any>): boolean;
    getListeners(eventToken: EventToken<any>): EventListenerContainerEntry[];
    /**
     * Dispatches the given event to all listeners for the given event token.
     */
    dispatch<T extends EventToken<any>>(eventToken: T, ...args: DispatchArguments<T>): EventDispatcherDispatchType<T>;
    /**
     * Returns a dispatcher function for the given event token.
     * This is the most performant way to dispatch events, as it's pre-compiled
     * and if there are no listeners attached it's a noop.
     */
    getDispatcher<T extends EventToken<any>>(eventToken: T): Dispatcher<T>;
}

Errors

export class EventError extends CustomError {
}

Functions

(eventToken: any): eventToken is EventTokenSync<any>

(obj: any): obj is EventListenerContainerEntryCallback

(obj: any): obj is EventListenerContainerEntryService

(eventDispatcher: EventDispatcher, tokens: readonly EventToken<any>[]): { dispatches: [eventTokenId: string, event: any][]; messages: string[]; clear(): void; get<T extends EventToken>(token: T, filter?: (event: T extends EventToken<...> | EventTokenSync<...> ? E extends SimpleDataEvent<...> ? D : E : never) => boolean): T extends EventToken<...> | EventTokenSync<...> ? E extends SimpleDataEvent<...> ? D : E : never; }

ClassDecoratorResult<typeof EventClassApi>

PropertyDecoratorResult<typeof EventDispatcherApi>

Types

type EventListenerCallbackAsync<E> = (event: E, ...args: any[]) => Promise<void> | void;

type EventListenerCallbackSync<E> = (event: E, ...args: any[]) => undefined | void;

type EventListenerCallback<T extends EventToken<any> | EventTokenSync<any>> = T extends EventTokenSync<any> ? EventListenerCallbackSync<T['event']> : EventListenerCallbackAsync<T['event']>;

interface EventListener {
    eventToken: EventToken<any>;
    callback: (event: any) => any;
    module?: InjectorModule,
    /**
     * The lower the order, the sooner the listener is called. Default is 0.
     */
    order: number;
}

Result of EventToken.listen(callback).

type EventOfEventToken<T> = T extends EventToken<infer E> | EventTokenSync<infer E> ? EventOfEvent<E> : void;

Extract the event type of EventToken.

type Dispatcher<T extends EventToken<any>> = (...args: DispatchArguments<T>) => EventDispatcherDispatchType<T>;

type DispatchArguments<T extends EventToken<any>> =
    T extends EventToken<infer E> | EventTokenSync<infer E>
        ? SimpleDataEvent<any> extends E
            ? E extends SimpleDataEvent<infer D>
                ? [event: ValueOrFactory<D | E>, injector?: InjectorContext]
                : BaseEvent extends E
                    ? [event?: ValueOrFactory<E>, injector?: InjectorContext]
                    : [event: ValueOrFactory<E>, injector?: InjectorContext]
            : BaseEvent extends E
                ? [event?: ValueOrFactory<E>, injector?: InjectorContext]
                : [event: ValueOrFactory<E>, injector?: InjectorContext]
        : [event: 'invalid-token', injector?: InjectorContext];

type EventListenerContainerEntryCallback = {
    order: number,
    fn: EventListenerCallback<any>,
    module?: InjectorModule,
    builtFn?: BuiltFn,
};

type EventListenerContainerEntryService = {
    module: InjectorModule,
    order: number,
    classType: ClassType,
    methodName: string;
    builtFn?: BuiltFn,
};

type EventListenerContainerEntry = EventListenerContainerEntryCallback | EventListenerContainerEntryService;

type EventDispatcherUnsubscribe = () => void;

type EventDispatcherDispatchType<T extends EventToken<any>> = T extends EventTokenSync<any> ? void : Promise<void>;

interface EventListenerRegistered {
    listener: EventListenerContainerEntry;
    eventToken: EventToken<any>;
}