feat(node): v11.13

types/node/crypto.d.ts

@@ -261,7 +261,7 @@ declare module "crypto" {
     }
 
     function createPrivateKey(key: PrivateKeyInput | string | Buffer): KeyObject;
-    function createPublicKey(key: PublicKeyInput | string | Buffer): KeyObject;
+    function createPublicKey(key: PublicKeyInput | string | Buffer | KeyObject): KeyObject;
     function createSecretKey(key: Buffer): KeyObject;
 
     function createSign(algorithm: string, options?: stream.WritableOptions): Signer;

types/node/events.d.ts

@@ -5,6 +5,7 @@ declare module "events" {
          class EventEmitter extends internal {
             /** @deprecated since v4.0.0 */
             static listenerCount(emitter: EventEmitter, event: string | symbol): number;
+            static once(emitter: EventEmitter, event: string | symbol): Promise<any>;
             static defaultMaxListeners: number;
 
             addListener(event: string | symbol, listener: (...args: any[]) => void): this;

types/node/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for non-npm package Node.js 11.12
+// Type definitions for non-npm package Node.js 11.13
 // Project: http://nodejs.org/
 // Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
 //                 DefinitelyTyped <https://github.com/DefinitelyTyped>

types/node/node-tests.ts

@@ -1,7 +1,5 @@
 import assert = require("assert");
 import * as fs from "fs";
-import * as events from "events";
-import events2 = require("events");
 import * as url from "url";
 import * as util from "util";
 import * as http from "http";
@@ -10,84 +8,12 @@ import * as vm from "vm";
 import * as console2 from "console";
 import * as string_decoder from "string_decoder";
 import * as timers from "timers";
-import * as v8 from "v8";
 import * as dns from "dns";
 import * as async_hooks from "async_hooks";
 import * as inspector from "inspector";
 import * as trace_events from "trace_events";
 import Module = require("module");
 
-////////////////////////////////////////////////////
-/// Events tests : http://nodejs.org/api/events.html
-////////////////////////////////////////////////////
-
-{
-    const emitter: events.EventEmitter = new events.EventEmitter();
-    const event: string | symbol = '';
-    const listener: (...args: any[]) => void = () => {};
-    const any: any = 1;
-
-    {
-        let result: events.EventEmitter;
-
-        result = emitter.addListener(event, listener);
-        result = emitter.on(event, listener);
-        result = emitter.once(event, listener);
-        result = emitter.prependListener(event, listener);
-        result = emitter.prependOnceListener(event, listener);
-        result = emitter.removeListener(event, listener);
-        result = emitter.off(event, listener);
-        result = emitter.removeAllListeners();
-        result = emitter.removeAllListeners(event);
-        result = emitter.setMaxListeners(42);
-    }
-
-    {
-        let result: number;
-
-        result = events.EventEmitter.defaultMaxListeners;
-        result = events.EventEmitter.listenerCount(emitter, event); // deprecated
-
-        result = emitter.getMaxListeners();
-        result = emitter.listenerCount(event);
-    }
-
-    {
-        let result: Function[];
-
-        result = emitter.listeners(event);
-    }
-
-    {
-        let result: boolean;
-
-        result = emitter.emit(event);
-        result = emitter.emit(event, any);
-        result = emitter.emit(event, any, any);
-        result = emitter.emit(event, any, any, any);
-    }
-
-    {
-        let result: Array<string | symbol>;
-
-        result = emitter.eventNames();
-    }
-
-    {
-        class Networker extends events.EventEmitter {
-            constructor() {
-                super();
-
-                this.emit("mingling");
-            }
-        }
-    }
-
-    {
-        new events2();
-    }
-}
-
 ////////////////////////////////////////////////////
 /// File system tests : http://nodejs.org/api/fs.html
 ////////////////////////////////////////////////////
@@ -1083,19 +1009,6 @@ import * as constants from 'constants';
     str = constants.defaultCipherList;
 }
 
-////////////////////////////////////////////////////
-/// v8 tests : https://nodejs.org/api/v8.html
-////////////////////////////////////////////////////
-
-{
-    const heapStats = v8.getHeapStatistics();
-    const heapSpaceStats = v8.getHeapSpaceStatistics();
-
-    const zapsGarbage: number = heapStats.does_zap_garbage;
-
-    v8.setFlagsFromString('--collect_maps');
-}
-
 ////////////////////////////////////////////////////
 /// AsyncHooks tests : https://nodejs.org/api/async_hooks.html
 ////////////////////////////////////////////////////

types/node/test/events.ts

@@ -0,0 +1,68 @@
+import * as events from 'events';
+
+const emitter: events.EventEmitter = new events.EventEmitter();
+const event: string | symbol = '';
+const listener: (...args: any[]) => void = () => {};
+const any: any = 1;
+
+{
+    let result: events.EventEmitter;
+
+    result = emitter.addListener(event, listener);
+    result = emitter.on(event, listener);
+    result = emitter.once(event, listener);
+    result = emitter.prependListener(event, listener);
+    result = emitter.prependOnceListener(event, listener);
+    result = emitter.removeListener(event, listener);
+    result = emitter.off(event, listener);
+    result = emitter.removeAllListeners();
+    result = emitter.removeAllListeners(event);
+    result = emitter.setMaxListeners(42);
+}
+
+{
+    let result: number;
+
+    result = events.EventEmitter.defaultMaxListeners;
+    result = events.EventEmitter.listenerCount(emitter, event); // deprecated
+
+    const promise: Promise<any> = events.once(new events.EventEmitter(), 'error');
+
+    result = emitter.getMaxListeners();
+    result = emitter.listenerCount(event);
+}
+
+{
+    let result: Function[];
+
+    result = emitter.listeners(event);
+}
+
+{
+    let result: boolean;
+
+    result = emitter.emit(event);
+    result = emitter.emit(event, any);
+    result = emitter.emit(event, any, any);
+    result = emitter.emit(event, any, any, any);
+}
+
+{
+    let result: Array<string | symbol>;
+
+    result = emitter.eventNames();
+}
+
+{
+    class Networker extends events.EventEmitter {
+        constructor() {
+            super();
+
+            this.emit("mingling");
+        }
+    }
+}
+
+{
+    new events();
+}

types/node/test/tty.ts

@@ -21,5 +21,6 @@ ws.getColorDepth({
 });
 ws.clearScreenDown();
 ws.getWindowSize();
+const hasCOlors: boolean = ws.hasColors();
 
 const isTTY: boolean = tty.isatty(1);

types/node/test/v8.ts

@@ -0,0 +1,12 @@
+import * as v8 from 'v8';
+import { Readable } from 'stream';
+
+const heapStats = v8.getHeapStatistics();
+const heapSpaceStats = v8.getHeapSpaceStatistics();
+
+const zapsGarbage: number = heapStats.does_zap_garbage;
+
+v8.setFlagsFromString('--collect_maps');
+
+const stream: Readable = v8.getHeapSnapshot();
+const fileName = v8.writeHeapSnapshot('file');

types/node/test/worker_threads.ts

@@ -1,5 +1,7 @@
 import * as workerThreads from "worker_threads";
 import assert = require("assert");
+import { worker } from "cluster";
+import { createContext } from "vm";
 
 {
     if (workerThreads.isMainThread) {
@@ -36,6 +38,7 @@ import assert = require("assert");
         subChannel.port2.on('message', (value) => {
             console.log('received:', value);
         });
+        worker.moveMessagePortToContext(new workerThreads.MessagePort(), createContext());
     } else {
         workerThreads.parentPort!.once('message', (value) => {
             assert(value.hereIsYourPort instanceof workerThreads.MessagePort);

types/node/tsconfig.json

@@ -50,6 +50,7 @@
         "test/cluster.ts",
         "test/crypto.ts",
         "test/dgram.ts",
+        "test/events.ts",
         "test/global.ts",
         "test/http.ts",
         "test/http2.ts",
@@ -65,6 +66,7 @@
         "test/tls.ts",
         "test/tty.ts",
         "test/util.ts",
+        "test/v8.ts",
         "test/worker_threads.ts",
         "test/zlib.ts"
     ],

types/node/tty.d.ts

@@ -39,6 +39,9 @@ declare module "tty" {
          * @default `process.env`
          */
         getColorDepth(env?: {}): number;
+        hasColors(depth?: number): boolean;
+        hasColors(env?: {}): boolean;
+        hasColors(depth: number, env?: {}): boolean;
         getWindowSize(): [number, number];
         columns: number;
         rows: number;

types/node/v8.d.ts

@@ -1,4 +1,7 @@
+
 declare module "v8" {
+    import { Readable } from "stream";
+
     interface HeapSpaceInfo {
         space_name: string;
         space_size: number;
@@ -25,4 +28,24 @@ declare module "v8" {
     function getHeapStatistics(): HeapInfo;
     function getHeapSpaceStatistics(): HeapSpaceInfo[];
     function setFlagsFromString(flags: string): void;
+    /**
+     * Generates a snapshot of the current V8 heap and returns a Readable
+     * Stream that may be used to read the JSON serialized representation.
+     * This conversation was marked as resolved by joyeecheung
+     * This JSON stream format is intended to be used with tools such as
+     * Chrome DevTools. The JSON schema is undocumented and specific to the
+     * V8 engine, and may change from one version of V8 to the next.
+     */
+    function getHeapSnapshot(): Readable;
+
+    /**
+     *
+     * @param fileName The file path where the V8 heap snapshot is to be
+     * saved. If not specified, a file name with the pattern
+     * `'Heap-${yyyymmdd}-${hhmmss}-${pid}-${thread_id}.heapsnapshot'` will be
+     * generated, where `{pid}` will be the PID of the Node.js process,
+     * `{thread_id}` will be `0` when `writeHeapSnapshot()` is called from
+     * the main Node.js thread or the id of a worker thread.
+     */
+    function writeHeapSnapshot(fileName?: string): string;
 }

types/node/worker_threads.d.ts

@@ -1,4 +1,6 @@
+
 declare module "worker_threads" {
+    import { Context } from "vm";
     import { EventEmitter } from "events";
     import { Readable, Writable } from "stream";
 
@@ -73,6 +75,21 @@ declare module "worker_threads" {
         ref(): void;
         unref(): void;
         terminate(callback?: (err: Error, exitCode: number) => void): void;
+        /**
+         * Transfer a `MessagePort` to a different `vm` Context. The original `port`
+         * object will be rendered unusable, and the returned `MessagePort` instance will
+         * take its place.
+         *
+         * The returned `MessagePort` will be an object in the target context, and will
+         * inherit from its global `Object` class. Objects passed to the
+         * `port.onmessage()` listener will also be created in the target context
+         * and inherit from its global `Object` class.
+         *
+         * However, the created `MessagePort` will no longer inherit from
+         * `EventEmitter`, and only `port.onmessage()` can be used to receive
+         * events using it.
+         */
+        moveMessagePortToContext(port: MessagePort, context: Context): MessagePort;
 
         addListener(event: "error", listener: (err: Error) => void): this;
         addListener(event: "exit", listener: (exitCode: number) => void): this;