package/package.json000666 0000001520 3560116604 011550 0ustar00000000 000000 { "name": "strict-event-emitter-types", "version": "2.0.0", "description": "Strictly and safely type any EventEmitter-like interface on any object", "main": "dist/src/index.js", "scripts": { "build": "tsc", "prepublish": "npm run build" }, "types": "types/src", "repository": { "type": "git", "url": "git+https://github.com/bterlson/typed-event-emitter.git" }, "keywords": [ "TypeScript", "TS", "EventEmitter", "events" ], "files": [ "types" ], "author": "Brian Terlson ", "license": "ISC", "bugs": { "url": "https://github.com/bterlson/typed-event-emitter/issues" }, "homepage": "https://github.com/bterlson/typed-event-emitter#readme", "dependencies": {}, "devDependencies": { "@types/node": "^9.4.6", "typescript": "next" } } package/README.md000666 0000010336 3560116604 010546 0ustar00000000 000000 ## Typed Event Emitter **NOTE: REQUIRES TYPESCRIPT 3.0** A TypeScript library for strongly typed event emitters in 0 kB. Declare events using a simple interface mapping event names to their payloads to get stricter versions of `emit`, `on`, and other common EventEmitter APIs. Works with any kind of EventEmitter. ### Installation ``` npm i strict-event-emitter-types ``` ### Example ```ts import StrictEventEmitter from 'strict-event-emitter-types'; // define your events interface Events { request: (request: Request, response: Response) => void; done: void; } // grab an event emitter import { EventEmitter } from 'events'; // Create strict event emitter types let ee: StrictEventEmitter = new EventEmitter; // now enjoy your strongly typed EventEmitter API!🎉 ee.on('request', (r, resp) => ... ); // r and resp are contextually typed to Request and Response ee.on('somethingElse'); // Error: unknown event ee.on('done', x => x); // Error: The 'done' event does not have a payload ee.emit('request', new Request()); // Error: missing event payload (the response) ee.emit('request', new Request(), false); // Error: incorrect payload type ``` ### Usage #### Event Records Event records are interfaces or object types that map event names to the event's payload types. In the following example, three events are declared: ```ts interface Events { req: (request: Request, response: Response) => void; done: void; conn: Connection; } ``` Each event shows one of three ways to type the event payloads: 1. **Function type:** Parameters are the event payload. The return type is ignored. 1. **`void`:** A shortcut for an event with no payload, i.e. `() => void` 1. **Anything else:** A shortcut for an event with one payload, for example `(p: number) => void` can be written as just `number`. #### StrictEventEmitter<TEmitterType, TEventRecord, TEmitRecord> The default export. A generic type that takes three type parameters: 1. _TEmitterType_: Your EventEmitter type (e.g. node's EventEmitter or socket.io socket) 2. _TEventRecord_: A type mapping event names to event payloads 3. _TEmitRecord_: Optionally, a similar type mapping things you can emit. The third parameter is handy when typing web sockets where client and server can listen to and emit different events. For example, if you are using socket.io: ```ts // create types representing the server side and client // side sockets export type ServerSocket = StrictEventEmitter; export type ClientSocket = StrictEventEmitter; // elsewhere on server let serverSocket: ServerSocket = new SocketIO.Socket(); serverSocket.on(/* only events that are sent from the client are allowed */, ...) serverSocket.emit(/* only events that are emitted from the server are allowed */, ...) // elsewhere on client let clientSocket: ClientSocket = new SocketIOClient.Socket(); clientSocket.on(/* only events that are sent from the server are allowed */, ...) clientSocket.emit(/* only events that are emitted from the client are allowed */, ...) ``` ##### Usage with Subclasses To subclass an EventEmitter you need to cast the base EventEmitter to the strict EventEmitter before extending: ```ts type MyEmitter = StrictEventEmitter; class MyEventEmitter extends (EventEmitter as { new(): MyEmitter }) { doEmit() { this.emit(...); // strict } } ``` ### StrictBroadcast<TStrictEventEmitter> A type for a function which takes (and strictly checks) an emit event and a payload. _TStrictEventEmitter_ is the event emitter type instantiated from StrictEventEmitter. Useful for broadcast abstractions. It is not possible to contextually type assigments to this type, so your declarations will look something like this: ```ts import { StrictBroadcast } from 'strict-event-emitter-types'; const broadcast: StrictBroadcast = function( event: string, payload?: any ) { // ... }; ``` Note that the loose types for event and payload only apply inside the broadcast function (consumers will see a much stricter signature). Declaring more precise parameter types or narrowing using type guards would allow strongly-typed dispatching to emitters. package/dist/src/index.js000666 0000000117 3560116604 012462 0ustar00000000 000000 "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); package/types/src/index.d.ts000666 0000011662 3560116604 013126 0ustar00000000 000000 declare const assignmentCompatibilityHack: unique symbol; export declare type MatchingKeys = K extends (TRecord[K] extends TMatch ? K : never) ? K : never; export declare type VoidKeys = MatchingKeys; export interface TypeRecord { ' _emitterType'?: T; ' _eventsType'?: U; ' _emitType'?: V; } export declare type ReturnTypeOfMethod = T extends (...args: any[]) => any ? ReturnType : void; export declare type ReturnTypeOfMethodIfExists = S extends keyof T ? ReturnTypeOfMethod : void; export declare type InnerEEMethodReturnType = T extends (...args: any[]) => any ? ReturnType extends void | undefined ? FValue : TValue : FValue; export declare type EEMethodReturnType = S extends keyof T ? InnerEEMethodReturnType : FValue; declare type ListenerType = [T] extends [(...args: infer U) => any] ? U : [T] extends [void] ? [] : [T]; export declare type OverriddenMethods = { on

(this: T, event: P, listener: (...args: ListenerType) => void): EEMethodReturnType; on(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void; addListener

(this: T, event: P, listener: (...args: ListenerType) => void): EEMethodReturnType; addListener(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void; addEventListener

(this: T, event: P, listener: (...args: ListenerType) => void): EEMethodReturnType; addEventListener(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void; removeListener

(this: T, event: P, listener: (...args: any[]) => any): EEMethodReturnType; removeListener(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void; removeEventListener

(this: T, event: P, listener: (...args: any[]) => any): EEMethodReturnType; removeEventListener(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void; once

(this: T, event: P, listener: (...args: ListenerType) => void): EEMethodReturnType; once(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void; emit

(this: T, event: P, ...args: ListenerType): EEMethodReturnType; emit(event: typeof assignmentCompatibilityHack, ...args: any[]): void; }; export declare type OverriddenKeys = keyof OverriddenMethods; export declare type StrictEventEmitter = Exclude, NeededMethods extends Exclude = Exclude> = TypeRecord & Pick> & Pick, NeededMethods>; export default StrictEventEmitter; export declare type NoUndefined = T extends undefined ? never : T; export declare type StrictBroadcast, TEmitRecord extends NoUndefined = NoUndefined, VK extends VoidKeys = VoidKeys, NVK extends Exclude = Exclude> = { (event: E, request: TEmitRecord[E]): any; (event: E): any; }; export declare type EventNames, TEventRecord extends NoUndefined = NoUndefined, TEmitRecord extends NoUndefined = NoUndefined> = keyof TEmitRecord | keyof TEventRecord; export declare type OnEventNames, TEventRecord extends NoUndefined = NoUndefined, TEmitRecord extends NoUndefined = NoUndefined> = keyof TEventRecord; export declare type EmitEventNames, TEventRecord extends NoUndefined = NoUndefined, TEmitRecord extends NoUndefined = NoUndefined> = keyof TEmitRecord; package/types/test/examples.d.ts000666 0000000000 3560116604 014005 0ustar00000000 000000 package/types/test/test-fn.d.ts000666 0000000014 3560116604 013554 0ustar00000000 000000 export {}; package/types/test/test-val.d.ts000666 0000000014 3560116604 013733 0ustar00000000 000000 export {}; package/types/test/test.d.ts000666 0000000014 3560116604 013153 0ustar00000000 000000 export {};