Node.js v16

Author: exoego

app/nodejs-v16/src/main/scala/io/scalajs/nodejs/Assert.scala

@@ -4,25 +4,28 @@ import scala.scalajs.js
 import scala.scalajs.js.annotation.JSImport
 
 /** The assert module provides a simple set of assertion tests that can be used to test invariants. The module is
-  * intended for internal use by Node.js, but can be used in application code via require('assert'). However, assert
-  * is not a testing framework, and is not intended to be used as a general purpose assertion library.
+  * intended for internal use by Node.js, but can be used in application code via require('assert'). However, assert is
+  * not a testing framework, and is not intended to be used as a general purpose assertion library.
   *
-  * The API for the assert module is Locked. This means that there will be no additions or changes to any of the
-  * methods implemented and exposed by the module.
+  * The API for the assert module is Locked. This means that there will be no additions or changes to any of the methods
+  * implemented and exposed by the module.
   */
 @js.native
 trait Assert extends js.Object {
 
   /** An alias of assert.ok() .
-    * @param expression the expression to evaluate
-    * @example assert(value[, message])
+    * @param expression
+    *   the expression to evaluate
+    * @example
+    *   assert(value[, message])
     */
   def apply(expression: js.Any, message: String): Unit = js.native
   def apply(expression: js.Any): Unit                  = js.native
 
   /** Generally identical to assert.deepEqual() with two exceptions. First, primitive values are compared using the
     * strict equality operator ( === ). Second, object comparisons include a strict equality check of their prototypes.
-    * @example assert.deepStrictEqual(actual, expected[, message])
+    * @example
+    *   assert.deepStrictEqual(actual, expected[, message])
     */
   def deepStrictEqual(actual: js.Any, expected: js.Any, message: String): Unit = js.native
   def deepStrictEqual(actual: js.Any, expected: js.Any): Unit                  = js.native
@@ -40,11 +43,12 @@ trait Assert extends js.Object {
   def doesNotReject(asyncFn: js.Promise[_], message: String): Unit                     = js.native
   def doesNotReject(asyncFn: js.Promise[_]): Unit                                      = js.native
 
-  /** Asserts that the function block does not throw an error. See assert.throws() for more details.
-    * When assert.doesNotThrow() is called, it will immediately call the block function. If an error is thrown
-    * and it is the same type as that specified by the error parameter, then an AssertionError is thrown. If the
-    * error is of a different type, or if the error parameter is undefined, the error is propagated back to the caller.
-    * @example assert.doesNotThrow(block[, error][, message])
+  /** Asserts that the function block does not throw an error. See assert.throws() for more details. When
+    * assert.doesNotThrow() is called, it will immediately call the block function. If an error is thrown and it is the
+    * same type as that specified by the error parameter, then an AssertionError is thrown. If the error is of a
+    * different type, or if the error parameter is undefined, the error is propagated back to the caller.
+    * @example
+    *   assert.doesNotThrow(block[, error][, message])
     */
   def doesNotThrow(block: js.Function, error: js.RegExp, message: String): Unit   = js.native
   def doesNotThrow(block: js.Function, error: js.RegExp): Unit                    = js.native
@@ -53,50 +57,57 @@ trait Assert extends js.Object {
   def doesNotThrow(block: js.Function, message: String): Unit                     = js.native
   def doesNotThrow(block: js.Function): Unit                                      = js.native
 
-  /** @see https://nodejs.org/api/assert.html#assert_assert_fail_message
+  /** @see
+    *   https://nodejs.org/api/assert.html#assert_assert_fail_message
     */
   def fail(message: String): Unit = js.native
 
-  /** @see https://nodejs.org/api/assert.html#assert_assert_fail_message
+  /** @see
+    *   https://nodejs.org/api/assert.html#assert_assert_fail_message
     */
   def fail(message: js.Error): Unit = js.native
 
   @deprecated("Use assert.fail([message]) or other assert functions instead.", "Node.js v10.0.0")
   def fail(actual: js.Any, expected: js.Any, message: String, operator: String): Unit = js.native
 
   /** Throws value if value is truthy. This is useful when testing the error argument in callbacks.
-    * @example assert.ifError(value)
+    * @example
+    *   assert.ifError(value)
     */
   def ifError(value: js.Any): Unit = js.native
 
   /** Tests for deep strict inequality. Opposite of assert.deepStrictEqual().
-    * @example assert.notDeepStrictEqual(actual, expected[, message])
+    * @example
+    *   assert.notDeepStrictEqual(actual, expected[, message])
     */
   def notDeepStrictEqual(actual: js.Any, expected: js.Any, message: String): Unit = js.native
   def notDeepStrictEqual(actual: js.Any, expected: js.Any): Unit                  = js.native
 
   /** Tests strict inequality as determined by the strict not equal operator ( !== ).
-    * @example assert.notStrictEqual(actual, expected[, message])
+    * @example
+    *   assert.notStrictEqual(actual, expected[, message])
     */
   def notStrictEqual(actual: js.Any, expected: js.Any, message: String): Unit = js.native
   def notStrictEqual(actual: js.Any, expected: js.Any): Unit                  = js.native
 
-  /** Tests if value is truthy. It is equivalent to assert.equal(!!value, true, message). If value is not truthy,
-    * an AssertionError is thrown with a message property set equal to the value of the message parameter. If the
-    * message parameter is undefined, a default error message is assigned.
+  /** Tests if value is truthy. It is equivalent to assert.equal(!!value, true, message). If value is not truthy, an
+    * AssertionError is thrown with a message property set equal to the value of the message parameter. If the message
+    * parameter is undefined, a default error message is assigned.
     */
   def ok(value: js.Any, message: String): Unit = js.native
   def ok(value: js.Any): Unit                  = js.native
 
   /** Tests strict equality as determined by the strict equality operator ( === ).
-    * @example assert.strictEqual(actual, expected[, message])
+    * @example
+    *   assert.strictEqual(actual, expected[, message])
     */
   def strictEqual(actual: js.Any, expected: js.Any, message: String): Unit = js.native
   def strictEqual(actual: js.Any, expected: js.Any): Unit                  = js.native
 
   /** If the values are not strictly equal, an AssertionError is thrown with a message property set equal to the value
     * of the message parameter. If the message parameter is undefined, a default error message is assigned.
-    * @example assert.throws(block[, error][, message])
+    * @example
+    *   assert.throws(block[, error][, message])
     */
   def throws(block: js.Function, error: js.Object, message: String): Unit = js.native
   def throws(block: js.Function, error: js.Object): Unit                  = js.native

app/nodejs-v16/src/main/scala/io/scalajs/nodejs/Error.scala

@@ -5,30 +5,27 @@ import com.thoughtworks.enableIf
 import scala.scalajs.js
 import scala.scalajs.js.annotation.JSGlobal
 
-/** Creates a new Error object and sets the error.message property to the provided text message.
-  * If an object is passed as message, the text message is generated by calling message.toString().
-  * The error.stack property will represent the point in the code at which new Error() was called.
-  * Stack traces are dependent on V8's stack trace API. Stack traces extend only to either (a) the
-  * beginning of synchronous code execution, or (b) the number of frames given by the property
-  * Error.stackTraceLimit, whichever is smaller.
+/** Creates a new Error object and sets the error.message property to the provided text message. If an object is passed
+  * as message, the text message is generated by calling message.toString(). The error.stack property will represent the
+  * point in the code at which new Error() was called. Stack traces are dependent on V8's stack trace API. Stack traces
+  * extend only to either (a) the beginning of synchronous code execution, or (b) the number of frames given by the
+  * property Error.stackTraceLimit, whichever is smaller.
   */
 @js.native
 @JSGlobal
 class Error() extends js.Object {
   def this(message0: String) = this()
 
-  /** The `error.code` property is a string label that identifies the kind of error.
-    * `error.code` is the most stable way to identify an error.
-    * It will only change between major versions of Node.js.
-    * In contrast, error.message strings may change between any versions of Node.js
-    * See Node.js Error Codes for details about specific codes.
+  /** The `error.code` property is a string label that identifies the kind of error. `error.code` is the most stable way
+    * to identify an error. It will only change between major versions of Node.js. In contrast, error.message strings
+    * may change between any versions of Node.js See Node.js Error Codes for details about specific codes.
     */
   val code: String = js.native
 
-  /** The error.message property is the string description of the error as set by calling new Error(message).
-    * The message passed to the constructor will also appear in the first line of the stack trace of the Error,
-    * however changing this property after the Error object is created may not change the first line of the
-    * stack trace (for example, when error.stack is read before this property is changed).
+  /** The error.message property is the string description of the error as set by calling new Error(message). The
+    * message passed to the constructor will also appear in the first line of the stack trace of the Error, however
+    * changing this property after the Error object is created may not change the first line of the stack trace (for
+    * example, when error.stack is read before this property is changed).
     */
   val message: String = js.native
 
@@ -56,13 +53,15 @@ object Error extends js.Object {
 
   /** Creates a .stack property on targetObject, which when accessed returns a string representing the location in the
     * code at which Error.captureStackTrace() was called.
-    * @param targetObject   The first line of the trace, instead of being prefixed with ErrorType: message, will be the
-    *                       result of calling targetObject.toString().
-    * @param constructorOpt The optional constructorOpt argument accepts a function. If given, all frames above
-    *                       constructorOpt, including constructorOpt, will be omitted from the generated stack trace.
-    *                       The constructorOpt argument is useful for hiding implementation details of error generation
-    *                       from an end user.
-    * @example Error.captureStackTrace(targetObject[, constructorOpt])
+    * @param targetObject
+    *   The first line of the trace, instead of being prefixed with ErrorType: message, will be the result of calling
+    *   targetObject.toString().
+    * @param constructorOpt
+    *   The optional constructorOpt argument accepts a function. If given, all frames above constructorOpt, including
+    *   constructorOpt, will be omitted from the generated stack trace. The constructorOpt argument is useful for hiding
+    *   implementation details of error generation from an end user.
+    * @example
+    *   Error.captureStackTrace(targetObject[, constructorOpt])
     */
   def captureStackTrace(targetObject: js.Any, constructorOpt: js.Any): Unit = js.native
   def captureStackTrace(targetObject: js.Any): Unit                         = js.native

app/nodejs-v16/src/main/scala/io/scalajs/nodejs/Module.scala

@@ -2,52 +2,59 @@ package io.scalajs.nodejs
 
 import scala.scalajs.js
 
-/** In each module, the module free variable is a reference to the object representing the current module.
-  * For convenience, module.exports is also accessible via the exports module-global. module isn't actually
-  * a global but rather local to each module.
-  * @see [[https://nodejs.org/api/modules.html#modules_the_module_object]]
+/** In each module, the module free variable is a reference to the object representing the current module. For
+  * convenience, module.exports is also accessible via the exports module-global. module isn't actually a global but
+  * rather local to each module.
+  * @see
+  *   [[https://nodejs.org/api/modules.html#modules_the_module_object]]
   */
 @js.native
 trait Module extends js.Object {
 
   /** The module objects required by this one.
-    * @example module.children
+    * @example
+    *   module.children
     */
   var children: js.Array[Module] = js.native
 
-  /** The module.exports object is created by the Module system. Sometimes this is not acceptable;
-    * many want their module to be an instance of some class. To do this, assign the desired export
-    * object to module.exports. Note that assigning the desired object to exports will simply rebind
-    * the local exports variable, which is probably not what you want to do.
-    * @example module.exports
+  /** The module.exports object is created by the Module system. Sometimes this is not acceptable; many want their
+    * module to be an instance of some class. To do this, assign the desired export object to module.exports. Note that
+    * assigning the desired object to exports will simply rebind the local exports variable, which is probably not what
+    * you want to do.
+    * @example
+    *   module.exports
     */
   var exports: js.Object = js.native
 
   /** The fully resolved filename to the module.
-    * @example module.filename
+    * @example
+    *   module.filename
     */
   var filename: String = js.native
 
   /** The identifier for the module. Typically this is the fully resolved filename.
-    * @example module.id
+    * @example
+    *   module.id
     */
   var id: String = js.native
 
   /** Whether or not the module is done loading, or is in the process of loading.
-    * @example module.loaded
+    * @example
+    *   module.loaded
     */
   var loaded: Boolean = js.native
 
   /** The module that first required this one.
-    * @example module.parent
+    * @example
+    *   module.parent
     */
   var parent: js.Any = js.native
 
   var paths: js.Array[String] = js.native
 
   /** The module.require method provides a way to load a module as if require() was called from the original module.
-    * <p/><b>Note</b> that in order to do this, you must get a reference to the module object. Since require() returns the
-    * module.exports, and the module is typically only available within a specific module's code, it must be
+    * <p/><b>Note</b> that in order to do this, you must get a reference to the module object. Since require() returns
+    * the module.exports, and the module is typically only available within a specific module's code, it must be
     * explicitly exported in order to be used.
     */
   def require[T <: js.Any](id: String): T = js.native

app/nodejs-v16/src/main/scala/io/scalajs/nodejs/StringDecoder.scala

@@ -15,14 +15,16 @@ class StringDecoder() extends IEventEmitter {
   def this(encoding: String) = this()
 
   /** Returns any trailing bytes that were left in the buffer.
-    * @example decoder.end()
+    * @example
+    *   decoder.end()
     */
   def end(buffer: TypedArray[_, _]): String = js.native
   def end(buffer: DataView): String         = js.native
   def end(): String                         = js.native
 
   /** Returns a decoded string.
-    * @example decoder.write(buffer)
+    * @example
+    *   decoder.write(buffer)
     */
   def write(buffer: TypedArray[_, _]): String = js.native
   def write(buffer: DataView): String         = js.native

app/nodejs-v16/src/main/scala/io/scalajs/nodejs/SystemError.scala

@@ -8,28 +8,28 @@ import scala.scalajs.js.|
 @js.native
 trait SystemError extends Error {
 
-  /** The error.errno property is a number or a string. The number is a negative value which corresponds
-    * to the error code defined in libuv Error handling. See uv-errno.h header file (deps/uv/include/uv-errno.h
-    * in the Node.js source tree) for details. In case of a string, it is the same as error.code.
+  /** The error.errno property is a number or a string. The number is a negative value which corresponds to the error
+    * code defined in libuv Error handling. See uv-errno.h header file (deps/uv/include/uv-errno.h in the Node.js source
+    * tree) for details. In case of a string, it is the same as error.code.
     */
   val errno: String | Int = js.native
 
   /** The error.syscall property is a string describing the syscall that failed.
     */
   val syscall: String = js.native
 
-  /** When present (e.g. in fs or child_process), the error.path property is a string containing
-    * a relevant invalid pathname.
+  /** When present (e.g. in fs or child_process), the error.path property is a string containing a relevant invalid
+    * pathname.
     */
   val path: String = js.native
 
-  /** When present (e.g. in net or dgram), the error.address property is a string describing the address
-    * to which the connection failed.
+  /** When present (e.g. in net or dgram), the error.address property is a string describing the address to which the
+    * connection failed.
     */
   val address: String = js.native
 
-  /** When present (e.g. in net or dgram), the error.port property is a number representing the connection's
-    * port that is not available.
+  /** When present (e.g. in net or dgram), the error.port property is a number representing the connection's port that
+    * is not available.
     */
   val port: Int = js.native