@types/node 16.4.2 → 16.4.6

node/string_decoder.d.ts

@@ -1,11 +1,67 @@
+/**
+ * The `string_decoder` module provides an API for decoding `Buffer` objects into
+ * strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16
+ * characters. It can be accessed using:
+ *
+ * ```js
+ * const { StringDecoder } = require('string_decoder');
+ * ```
+ *
+ * The following example shows the basic use of the `StringDecoder` class.
+ *
+ * ```js
+ * const { StringDecoder } = require('string_decoder');
+ * const decoder = new StringDecoder('utf8');
+ *
+ * const cent = Buffer.from([0xC2, 0xA2]);
+ * console.log(decoder.write(cent));
+ *
+ * const euro = Buffer.from([0xE2, 0x82, 0xAC]);
+ * console.log(decoder.write(euro));
+ * ```
+ *
+ * When a `Buffer` instance is written to the `StringDecoder` instance, an
+ * internal buffer is used to ensure that the decoded string does not contain
+ * any incomplete multibyte characters. These are held in the buffer until the
+ * next call to `stringDecoder.write()` or until `stringDecoder.end()` is called.
+ *
+ * In the following example, the three UTF-8 encoded bytes of the European Euro
+ * symbol (`€`) are written over three separate operations:
+ *
+ * ```js
+ * const { StringDecoder } = require('string_decoder');
+ * const decoder = new StringDecoder('utf8');
+ *
+ * decoder.write(Buffer.from([0xE2]));
+ * decoder.write(Buffer.from([0x82]));
+ * console.log(decoder.end(Buffer.from([0xAC])));
+ * ```
+ * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/string_decoder.js)
+ */
 declare module 'string_decoder' {
     class StringDecoder {
         constructor(encoding?: BufferEncoding);
+        /**
+         * Returns a decoded string, ensuring that any incomplete multibyte characters at
+         * the end of the `Buffer`, or `TypedArray`, or `DataView` are omitted from the
+         * returned string and stored in an internal buffer for the next call to`stringDecoder.write()` or `stringDecoder.end()`.
+         * @since v0.1.99
+         * @param buffer A `Buffer`, or `TypedArray`, or `DataView` containing the bytes to decode.
+         */
         write(buffer: Buffer): string;
+        /**
+         * Returns any remaining input stored in the internal buffer as a string. Bytes
+         * representing incomplete UTF-8 and UTF-16 characters will be replaced with
+         * substitution characters appropriate for the character encoding.
+         *
+         * If the `buffer` argument is provided, one final call to `stringDecoder.write()`is performed before returning the remaining input.
+         * After `end()` is called, the `stringDecoder` object can be reused for new input.
+         * @since v0.9.3
+         * @param buffer A `Buffer`, or `TypedArray`, or `DataView` containing the bytes to decode.
+         */
         end(buffer?: Buffer): string;
     }
 }
-
 declare module 'node:string_decoder' {
     export * from 'string_decoder';
 }

node/timers/promises.d.ts

@@ -1,25 +1,113 @@
+/**
+ * The `timers/promises` API provides an alternative set of timer functions
+ * that return `Promise` objects. The API is accessible via`require('timers/promises')`.
+ *
+ * ```js
+ * import {
+ *   setTimeout,
+ *   setImmediate,
+ *   setInterval,
+ * } from 'timers/promises';
+ * ```
+ *
+ * ```js
+ * const {
+ *   setTimeout,
+ *   setImmediate,
+ *   setInterval,
+ * } = require('timers/promises');
+ * ```
+ * @since v15.0.0
+ */
 declare module 'timers/promises' {
     import { TimerOptions } from 'node:timers';
-
     /**
-     * Returns a promise that resolves after the specified delay in milliseconds.
-     * @param delay defaults to 1
+     * ```js
+     * import {
+     *   setTimeout,
+     * } from 'timers/promises';
+     *
+     * const res = await setTimeout(100, 'result');
+     *
+     * console.log(res);  // Prints 'result'
+     * ```
+     *
+     * ```js
+     * const {
+     *   setTimeout,
+     * } = require('timers/promises');
+     *
+     * setTimeout(100, 'result').then((res) => {
+     *   console.log(res);  // Prints 'result'
+     * });
+     * ```
+     * @since v15.0.0
+     * @param delay The number of milliseconds to wait before fulfilling the promise.
+     * @param value A value with which the promise is fulfilled.
      */
     function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;
-
     /**
-     * Returns a promise that resolves in the next tick.
+     * ```js
+     * import {
+     *   setImmediate,
+     * } from 'timers/promises';
+     *
+     * const res = await setImmediate('result');
+     *
+     * console.log(res);  // Prints 'result'
+     * ```
+     *
+     * ```js
+     * const {
+     *   setImmediate,
+     * } = require('timers/promises');
+     *
+     * setImmediate('result').then((res) => {
+     *   console.log(res);  // Prints 'result'
+     * });
+     * ```
+     * @since v15.0.0
+     * @param value A value with which the promise is fulfilled.
      */
     function setImmediate<T = void>(value?: T, options?: TimerOptions): Promise<T>;
-
     /**
+     * Returns an async iterator that generates values in an interval of `delay` ms.
+     *
+     * ```js
+     * import {
+     *   setInterval,
+     * } from 'timers/promises';
+     *
+     * const interval = 100;
+     * for await (const startTime of setInterval(interval, Date.now())) {
+     *   const now = Date.now();
+     *   console.log(now);
+     *   if ((now - startTime) > 1000)
+     *     break;
+     * }
+     * console.log(Date.now());
+     * ```
+     *
+     * ```js
+     * const {
+     *   setInterval,
+     * } = require('timers/promises');
+     * const interval = 100;
      *
-     * Returns an async iterator that generates values in an interval of delay ms.
-     * @param delay defaults to 1
+     * (async function() {
+     *   for await (const startTime of setInterval(interval, Date.now())) {
+     *     const now = Date.now();
+     *     console.log(now);
+     *     if ((now - startTime) > 1000)
+     *       break;
+     *   }
+     *   console.log(Date.now());
+     * })();
+     * ```
+     * @since v15.9.0
      */
     function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): AsyncIterable<T>;
 }
-
 declare module 'node:timers/promises' {
     export * from 'timers/promises';
 }

node/timers.d.ts

@@ -1,7 +1,16 @@
+/**
+ * The `timer` module exposes a global API for scheduling functions to
+ * be called at some future period of time. Because the timer functions are
+ * globals, there is no need to call `require('timers')` to use the API.
+ *
+ * The timer functions within Node.js implement a similar API as the timers API
+ * provided by Web Browsers but use a different internal implementation that is
+ * built around the Node.js [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout).
+ * @see [source](https://github.com/nodejs/node/blob/v16.4.2/lib/timers.js)
+ */
 declare module 'timers' {
     import { Abortable } from 'node:events';
     import { setTimeout as setTimeoutPromise, setImmediate as setImmediatePromise, setInterval as setIntervalPromise } from 'node:timers/promises';
-
     interface TimerOptions extends Abortable {
         /**
          * Set to `false` to indicate that the scheduled `Timeout`
@@ -10,14 +19,12 @@ declare module 'timers' {
          */
         ref?: boolean | undefined;
     }
-
     let setTimeout: typeof global.setTimeout;
     let clearTimeout: typeof global.clearTimeout;
     let setInterval: typeof global.setInterval;
     let clearInterval: typeof global.clearInterval;
     let setImmediate: typeof global.setImmediate;
     let clearImmediate: typeof global.clearImmediate;
-
     global {
         namespace NodeJS {
             // compatibility with older typings
@@ -26,19 +33,35 @@ declare module 'timers' {
                 refresh(): this;
                 [Symbol.toPrimitive](): number;
             }
-
             interface Immediate extends RefCounted {
+                /**
+                 * If true, the `Immediate` object will keep the Node.js event loop active.
+                 * @since v11.0.0
+                 */
                 hasRef(): boolean;
                 _onImmediate: Function; // to distinguish it from the Timeout class
             }
-
             interface Timeout extends Timer {
+                /**
+                 * If true, the `Timeout` object will keep the Node.js event loop active.
+                 * @since v11.0.0
+                 */
                 hasRef(): boolean;
+                /**
+                 * Sets the timer's start time to the current time, and reschedules the timer to
+                 * call its callback at the previously specified duration adjusted to the current
+                 * time. This is useful for refreshing a timer without allocating a new
+                 * JavaScript object.
+                 *
+                 * Using this on a timer that has already called its callback will reactivate the
+                 * timer.
+                 * @since v10.2.0
+                 * @return a reference to `timeout`
+                 */
                 refresh(): this;
                 [Symbol.toPrimitive](): number;
             }
         }
-
         function setTimeout<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timeout;
         // util.promisify no rest args compability
         // tslint:disable-next-line void-return
@@ -47,7 +70,6 @@ declare module 'timers' {
             const __promisify__: typeof setTimeoutPromise;
         }
         function clearTimeout(timeoutId: NodeJS.Timeout): void;
-
         function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timer;
         // util.promisify no rest args compability
         // tslint:disable-next-line void-return
@@ -56,7 +78,6 @@ declare module 'timers' {
             const __promisify__: typeof setIntervalPromise;
         }
         function clearInterval(intervalId: NodeJS.Timeout): void;
-
         function setImmediate<TArgs extends any[]>(callback: (...args: TArgs) => void, ...args: TArgs): NodeJS.Immediate;
         // util.promisify no rest args compability
         // tslint:disable-next-line void-return
@@ -65,11 +86,9 @@ declare module 'timers' {
             const __promisify__: typeof setImmediatePromise;
         }
         function clearImmediate(immediateId: NodeJS.Immediate): void;
-
         function queueMicrotask(callback: () => void): void;
     }
 }
-
 declare module 'node:timers' {
     export * from 'timers';
 }