@types/node 22.8.5 → 22.8.6

node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Thu, 31 Oct 2024 05:35:24 GMT
+ * Last updated: Thu, 31 Oct 2024 18:02:52 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

node/events.d.ts

@@ -34,7 +34,6 @@
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/events.js)
  */
-
 declare module "events" {
     import { AsyncResource, AsyncResourceOptions } from "node:async_hooks";
     // NOTE: This class is in the docs but is **not actually exported** by Node.
@@ -100,27 +99,23 @@ declare module "events" {
          */
         lowWaterMark?: number | undefined;
     }
-    interface EventEmitter<Events extends EventMap<Events> = {}> extends NodeJS.EventEmitter<Events> {}
-    type EventMap<Events> = Record<keyof Events, unknown[]>;
-    type Args<Events extends EventMap<Events>, EventName> = EventName extends keyof Events ? (
-            | Events[EventName]
-            | (EventName extends keyof EventEmitter.EventEmitterBuiltInEventMap
-                ? EventEmitter.EventEmitterBuiltInEventMap[EventName]
-                : never)
-        )
-        : (EventName extends keyof EventEmitter.EventEmitterBuiltInEventMap
-            ? EventEmitter.EventEmitterBuiltInEventMap[EventName]
-            : any[]);
-    type EventNames<Events extends EventMap<Events>> = {} extends Events ? (string | symbol)
-        : (keyof Events | keyof EventEmitter.EventEmitterBuiltInEventMap);
-    type Listener<Events extends EventMap<Events>, EventName> = EventName extends keyof Events ?
-            | ((...args: Events[EventName]) => void)
-            | (EventName extends keyof EventEmitter.EventEmitterBuiltInEventMap
-                ? (...args: EventEmitter.EventEmitterBuiltInEventMap[EventName]) => void
-                : never)
-        : (EventName extends keyof EventEmitter.EventEmitterBuiltInEventMap
-            ? (...args: EventEmitter.EventEmitterBuiltInEventMap[EventName]) => void
-            : (...args: any[]) => void);
+    interface EventEmitter<T extends EventMap<T> = DefaultEventMap> extends NodeJS.EventEmitter<T> {}
+    type EventMap<T> = Record<keyof T, any[]> | DefaultEventMap;
+    type DefaultEventMap = [never];
+    type AnyRest = [...args: any[]];
+    type Args<K, T> = T extends DefaultEventMap ? AnyRest : (
+        K extends keyof T ? T[K] : never
+    );
+    type Key<K, T> = T extends DefaultEventMap ? string | symbol : K | keyof T;
+    type Key2<K, T> = T extends DefaultEventMap ? string | symbol : K & keyof T;
+    type Listener<K, T, F> = T extends DefaultEventMap ? F : (
+        K extends keyof T ? (
+                T[K] extends unknown[] ? (...args: T[K]) => void : never
+            )
+            : never
+    );
+    type Listener1<K, T> = Listener<K, T, (...args: any[]) => void>;
+    type Listener2<K, T> = Listener<K, T, Function>;
 
     /**
      * The `EventEmitter` class is defined and exposed by the `node:events` module:
@@ -135,20 +130,10 @@ declare module "events" {
      * It supports the following option:
      * @since v0.1.26
      */
-    class EventEmitter<Events extends EventMap<Events> = {}> {
+    class EventEmitter<T extends EventMap<T> = DefaultEventMap> {
         constructor(options?: EventEmitterOptions);
 
-        // This "property" is used to brand a specific instance of the EventEmitter class with its Event map, which is needed
-        // in order to infer the map if we have a chain like `class A extends EventEmitter<{}>` (or many levels deep)
-        // It is also marked as possibly undefined in order to allow something like `const t: NodeJS.EventEmitter<{}> = { <insert implementation here> };`
-        readonly #internalTypeOnlyBrand?: Events;
-
-        [EventEmitter.captureRejectionSymbol]?<EventName extends EventNames<Events>>(
-            error: Error,
-            event: EventName,
-            ...args: Args<Events, EventName>
-        ): void;
-        [EventEmitter.captureRejectionSymbol]?(error: Error, event: string | symbol, ...args: any[]): void;
+        [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: Key<K, T>, ...args: Args<K, T>): void;
 
         /**
          * Creates a `Promise` that is fulfilled when the `EventEmitter` emits the given
@@ -229,11 +214,6 @@ declare module "events" {
          * ```
          * @since v11.13.0, v10.16.0
          */
-        static once<Events extends EventMap<Events>, EventName extends EventNames<Events>>(
-            emitter: EventEmitter<Events>,
-            eventName: EventName,
-            options?: StaticEventEmitterOptions,
-        ): Promise<Args<Events, EventName>>;
         static once(
             emitter: NodeJS.EventEmitter,
             eventName: string | symbol,
@@ -320,11 +300,6 @@ declare module "events" {
          * @since v13.6.0, v12.16.0
          * @return An `AsyncIterator` that iterates `eventName` events emitted by the `emitter`
          */
-        static on<Events extends EventMap<Events>, EventName extends EventNames<Events>>(
-            emitter: EventEmitter<Events>,
-            eventName: EventName,
-            options?: StaticEventEmitterIteratorOptions,
-        ): NodeJS.AsyncIterator<Args<Events, EventName>>;
         static on(
             emitter: NodeJS.EventEmitter,
             eventName: string | symbol,
@@ -335,27 +310,6 @@ declare module "events" {
             eventName: string,
             options?: StaticEventEmitterIteratorOptions,
         ): NodeJS.AsyncIterator<any[]>;
-        /**
-         * A class method that returns the number of listeners for the given `eventName` registered on the given `emitter`.
-         *
-         * ```js
-         * import { EventEmitter, listenerCount } from 'node:events';
-         *
-         * const myEmitter = new EventEmitter();
-         * myEmitter.on('event', () => {});
-         * myEmitter.on('event', () => {});
-         * console.log(listenerCount(myEmitter, 'event'));
-         * // Prints: 2
-         * ```
-         * @since v0.9.12
-         * @deprecated Since v3.2.0 - Use `listenerCount` instead.
-         * @param emitter The emitter to query
-         * @param eventName The event name
-         */
-        static listenerCount<Events extends EventMap<Events>, EventName extends EventNames<Events>>(
-            emitter: EventEmitter<Events>,
-            eventName: EventName,
-        ): number;
         /**
          * A class method that returns the number of listeners for the given `eventName` registered on the given `emitter`.
          *
@@ -401,14 +355,7 @@ declare module "events" {
          * ```
          * @since v15.2.0, v14.17.0
          */
-        static getEventListeners<Events extends EventMap<Events>, EventName extends EventNames<Events>>(
-            emitter: EventEmitter<Events>,
-            name: EventName,
-        ): Array<Listener<Events, EventName>>;
-        static getEventListeners(
-            emitter: EventTarget | NodeJS.EventEmitter,
-            name: string | symbol,
-        ): Function[];
+        static getEventListeners(emitter: EventTarget | NodeJS.EventEmitter, name: string | symbol): Function[];
         /**
          * Returns the currently set max amount of listeners.
          *
@@ -638,37 +585,16 @@ declare module "events" {
              */
             readonly asyncResource: EventEmitterReferencingAsyncResource;
         }
-
-        export interface EventEmitterBuiltInEventMap {
-            newListener: [eventName: string | symbol, listener: Function];
-            removeListener: [eventName: string | symbol, listener: Function];
-        }
     }
     global {
         namespace NodeJS {
-            interface EventEmitter<Events extends EventMap<Events> = {}> {
-                [EventEmitter.captureRejectionSymbol]?<EventName extends EventNames<Events>>(
-                    error: Error,
-                    event: EventName,
-                    ...args: Args<Events, EventName>
-                ): void;
-                [EventEmitter.captureRejectionSymbol]?<EventName extends string | symbol>(
-                    error: Error,
-                    event: EventName,
-                    ...args: Args<Events, EventName>
-                ): void;
+            interface EventEmitter<T extends EventMap<T> = DefaultEventMap> {
+                [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: Key<K, T>, ...args: Args<K, T>): void;
                 /**
                  * Alias for `emitter.on(eventName, listener)`.
                  * @since v0.1.26
                  */
-                addListener<EventName extends EventNames<Events>>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
-                addListener<EventName extends string | symbol>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
+                addListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
                  * Adds the `listener` function to the end of the listeners array for the event
                  * named `eventName`. No checks are made to see if the `listener` has already
@@ -700,14 +626,7 @@ declare module "events" {
                  * @param eventName The name of the event.
                  * @param listener The callback function
                  */
-                on<EventName extends EventNames<Events>>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
-                on<EventName extends string | symbol>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
+                on<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
                  * Adds a **one-time** `listener` function for the event named `eventName`. The
                  * next time `eventName` is triggered, this listener is removed and then invoked.
@@ -737,14 +656,7 @@ declare module "events" {
                  * @param eventName The name of the event.
                  * @param listener The callback function
                  */
-                once<EventName extends EventNames<Events>>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
-                once<EventName extends string | symbol>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
+                once<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
                  * Removes the specified `listener` from the listener array for the event named `eventName`.
                  *
@@ -827,26 +739,12 @@ declare module "events" {
                  * Returns a reference to the `EventEmitter`, so that calls can be chained.
                  * @since v0.1.26
                  */
-                removeListener<EventName extends EventNames<Events>>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
-                removeListener<EventName extends string | symbol>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
+                removeListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
                  * Alias for `emitter.removeListener()`.
                  * @since v10.0.0
                  */
-                off<EventName extends EventNames<Events>>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
-                off<EventName extends string | symbol>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
+                off<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
                  * Removes all listeners, or those of the specified `eventName`.
                  *
@@ -857,10 +755,7 @@ declare module "events" {
                  * Returns a reference to the `EventEmitter`, so that calls can be chained.
                  * @since v0.1.26
                  */
-                /* eslint-disable @definitelytyped/no-unnecessary-generics */
-                removeAllListeners<EventName extends EventNames<Events>>(eventName: EventName): this;
-                removeAllListeners<EventName extends string | symbol>(eventName?: EventName): this;
-                /* eslint-enable @definitelytyped/no-unnecessary-generics */
+                removeAllListeners(eventName?: Key<unknown, T>): this;
                 /**
                  * By default `EventEmitter`s will print a warning if more than `10` listeners are
                  * added for a particular event. This is a useful default that helps finding
@@ -889,12 +784,7 @@ declare module "events" {
                  * ```
                  * @since v0.1.26
                  */
-                listeners<EventName extends EventNames<Events>>(
-                    eventName: EventName,
-                ): Array<Listener<Events, EventName>>;
-                listeners<EventName extends string | symbol>(
-                    eventName: EventName,
-                ): Array<Listener<Events, EventName>>;
+                listeners<K>(eventName: Key<K, T>): Array<Listener2<K, T>>;
                 /**
                  * Returns a copy of the array of listeners for the event named `eventName`,
                  * including any wrappers (such as those created by `.once()`).
@@ -925,12 +815,7 @@ declare module "events" {
                  * ```
                  * @since v9.4.0
                  */
-                rawListeners<EventName extends EventNames<Events>>(
-                    eventName: EventName,
-                ): Array<Listener<Events, EventName>>;
-                rawListeners<EventName extends string | symbol>(
-                    eventName: EventName,
-                ): Array<Listener<Events, EventName>>;
+                rawListeners<K>(eventName: Key<K, T>): Array<Listener2<K, T>>;
                 /**
                  * Synchronously calls each of the listeners registered for the event named `eventName`, in the order they were registered, passing the supplied arguments
                  * to each.
@@ -971,14 +856,7 @@ declare module "events" {
                  * ```
                  * @since v0.1.26
                  */
-                emit<EventName extends EventNames<Events>>(
-                    eventName: EventName,
-                    ...args: Args<Events, EventName>
-                ): boolean;
-                emit<EventName extends string | symbol>(
-                    eventName: EventName,
-                    ...args: Args<Events, EventName>
-                ): boolean;
+                emit<K>(eventName: Key<K, T>, ...args: Args<K, T>): boolean;
                 /**
                  * Returns the number of listeners listening for the event named `eventName`.
                  * If `listener` is provided, it will return how many times the listener is found
@@ -987,14 +865,7 @@ declare module "events" {
                  * @param eventName The name of the event being listened for
                  * @param listener The event handler function
                  */
-                listenerCount<EventName extends EventNames<Events>>(
-                    eventName: EventName,
-                    listener?: Listener<Events, EventName>,
-                ): number;
-                listenerCount<EventName extends string | symbol>(
-                    eventName: EventName,
-                    listener?: Listener<Events, EventName>,
-                ): number;
+                listenerCount<K>(eventName: Key<K, T>, listener?: Listener2<K, T>): number;
                 /**
                  * Adds the `listener` function to the _beginning_ of the listeners array for the
                  * event named `eventName`. No checks are made to see if the `listener` has
@@ -1012,14 +883,7 @@ declare module "events" {
                  * @param eventName The name of the event.
                  * @param listener The callback function
                  */
-                prependListener<EventName extends EventNames<Events>>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
-                prependListener<EventName extends string | symbol>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
+                prependListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
                  * Adds a **one-time**`listener` function for the event named `eventName` to the _beginning_ of the listeners array. The next time `eventName` is triggered, this
                  * listener is removed, and then invoked.
@@ -1035,14 +899,7 @@ declare module "events" {
                  * @param eventName The name of the event.
                  * @param listener The callback function
                  */
-                prependOnceListener<EventName extends EventNames<Events>>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
-                prependOnceListener<EventName extends string | symbol>(
-                    eventName: EventName,
-                    listener: Listener<Events, EventName>,
-                ): this;
+                prependOnceListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
                  * Returns an array listing the events for which the emitter has registered
                  * listeners. The values in the array are strings or `Symbol`s.
@@ -1062,7 +919,7 @@ declare module "events" {
                  * ```
                  * @since v6.0.0
                  */
-                eventNames(): Array<(string | symbol)> & Array<EventNames<Events>>;
+                eventNames(): Array<(string | symbol) & Key2<unknown, T>>;
             }
         }
     }

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "22.8.5",
+    "version": "22.8.6",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -220,6 +220,6 @@
         "undici-types": "~6.19.8"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "7165aa45b80abb5ff9333ec6ca387d477f843670bbad567424c59b148b46fa23",
+    "typesPublisherContentHash": "b5e95f7873a1811a61b3409c809ee30655d0268d76d767dbe9efc27cb421459f",
     "typeScriptVersion": "4.8"
 }