refactor(utils)!: [createNodeError] use class expression pattern

- https://justinfagnani.com/2015/12/21/real-mixins-with-javascript-classes
- https://www.typescriptlang.org/docs/handbook/mixins.html

Signed-off-by: Lexus Drumgold <unicornware@flexdevelopment.llc>

Author: unicornware

README.md

@@ -141,12 +141,11 @@ interface ErrInvalidUrl extends NodeError<TypeError> {
  * @class
  *
  * @param {string} input - URL that failed to parse
- * @return {ErrInvalidUrl} `TypeError` instance
+ * @return {ErrInvalidUrl} New `TypeError` instance
  */
 const ERR_INVALID_URL: NodeErrorConstructor<
-  TypeErrorConstructor,
-  MessageFn<[string]>,
-  ErrInvalidUrl
+  ErrInvalidUrl,
+  MessageFn<[string]>
 > = createNodeError(
   ErrorCode.ERR_INVALID_URL,
   TypeError,
@@ -244,7 +243,7 @@ There is no default export.
 
 ### Error Models
 
-Constructor functions representing [Node.js error codes][7], callable with and without the `new` keyword. Constructor
+Constructor functions representing [Node.js error codes][7], callable **only** with the `new` keyword. Constructor
 arguments are used to generate error messages.
 
 Models can be imported individually:
@@ -578,15 +577,15 @@ Thrown when an unsupported URL scheme is used in an `import` statement. URL sche
 
 Creates a Node.js error constructor.
 
-If the given error `message` is a function, constructor arguments are passed to `message`. If the `message` is a string,
-constructor arguments are passed to [`util.format`][15] instead.
+Constructor arguments are passed to [`util.format`][15] if the error `message` is a string, or `message` itself if it is
+a function. Message functions will also be called with the new Node.js error instance as `this`.
 
 - `{ErrorCode}` **`code`** &mdash; Node.js error code
-- `{B extends ErrorConstructor}` **`Base`** &mdash; Error base class
-- `{M extends MessageFn | unknown[] | string}` **`message`** &mdash; Error message or message function
-- **Returns**: `{NodeErrorConstructor<B, M>}` `NodeError` constructor
+- `{ErrnodeConstructor}` **`Base`** &mdash; Error base class
+- `{Message}` **`message`** &mdash; Error message string or function
+- **Returns**: `{NodeErrorConstructor` `NodeError` constructor
 
-> **Source**: [`src/create-node-error.ts`](src/create-node-error.ts)
+> **Source**: [`src/utils/create-node-error.ts`](src/utils/create-node-error.ts)
 
 #### `determineSpecificType(value)`
 
@@ -595,7 +594,7 @@ Determines the specific type of a value for type-mismatch errors.
 - `{unknown}` **`value`** &mdash; Value to evaluate
 - **Returns**: `{string}` Specific type of `value`
 
-> **Source**: [`src/determine-specific-type.ts`](src/determine-specific-type.ts)
+> **Source**: [`src/utils/determine-specific-type.ts`](src/utils/determine-specific-type.ts)
 
 ## Types
 
@@ -608,14 +607,17 @@ This package is fully typed with [TypeScript][16]. It exports the following defi
 
 ### Interfaces
 
+- [`CallSite`](src/interfaces/call-site.ts)
 - [`ErrInvalidUrl`](src/interfaces/err-invalid-url.ts)
 - [`ErrnoException`](src/interfaces/errno-exception.ts)
+- [`NodeErrorConstructor`](src/interfaces/node-error-constructor.ts)
 
 ### Type Definitions
 
-- [`NodeError`](src/types/node-error.ts)
-- [`NodeErrorConstructor`](src/types/node-error-constructor.ts)
+- [`ErrnodeConstructor`](src/types/errnode-constructor.ts)
 - [`MessageFn`](src/types/fn-message.ts)
+- [`Message`](src/types/message.ts)
+- [`NodeError`](src/types/node-error.ts)
 
 ## Contribute
 

src/interfaces/__tests__/call-site.spec-d.ts

@@ -0,0 +1,91 @@
+/**
+ * @file Type Tests - CallSite
+ * @module errnode/interfaces/tests/unit-d/CallSite
+ */
+
+import type { Fn, Nullable, Optional } from '@flex-development/tutils'
+import type TestSubject from '../call-site'
+
+describe('unit-d:interfaces/CallSite', () => {
+  it('should extend NodeJS.CallSite', () => {
+    expectTypeOf<TestSubject>().toMatchTypeOf<NodeJS.CallSite>()
+  })
+
+  it('should match [getColumnNumber(): Nullable<number>]', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('getColumnNumber')
+      .toEqualTypeOf<() => Nullable<number>>()
+  })
+
+  it('should match [getEvalOrigin(): Optional<string>', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('getEvalOrigin')
+      .toEqualTypeOf<() => Optional<string>>()
+  })
+
+  it('should match [getFileName(): Optional<string>]', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('getFileName')
+      .toEqualTypeOf<() => Optional<string>>()
+  })
+
+  it('should match [getFunction(): Optional<Fn>]', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('getFunction')
+      .toEqualTypeOf<() => Optional<Fn>>()
+  })
+
+  it('should match [getFunctionName(): Nullable<Fn["name"]>', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('getFunctionName')
+      .toEqualTypeOf<() => Nullable<Fn['name']>>()
+  })
+
+  it('should match [getLineNumber(): Nullable<number>]', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('getLineNumber')
+      .toEqualTypeOf<() => Nullable<number>>()
+  })
+
+  it('should match [getMethodName(): Nullable<string>]', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('getMethodName')
+      .toEqualTypeOf<() => Nullable<string>>()
+  })
+
+  it('should match [getThis(): unknown]', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('getThis')
+      .toMatchTypeOf<() => unknown>()
+  })
+
+  it('should match [getTypeName(): Nullable<string>', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('getTypeName')
+      .toEqualTypeOf<() => Nullable<string>>()
+  })
+
+  it('should match [isConstructor(): boolean', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('isConstructor')
+      .toEqualTypeOf<() => boolean>()
+  })
+
+  it('should match [isEval(): boolean', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('isEval')
+      .toEqualTypeOf<() => boolean>()
+  })
+
+  it('should match [isNative(): boolean', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('isNative')
+      .toEqualTypeOf<() => boolean>()
+  })
+
+  it('should match [isToplevel(): boolean', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('isToplevel')
+      .toEqualTypeOf<() => boolean>()
+  })
+})

src/interfaces/__tests__/node-error-constructor.spec-d.ts

@@ -0,0 +1,89 @@
+/**
+ * @file Type Tests - NodeErrorConstructor
+ * @module errnode/interfaces/tests/unit-d/NodeErrorConstructor
+ */
+
+import type { MessageFn, NodeError } from '#src/types'
+import type {
+  Fn,
+  Optional,
+  Pick,
+  Times,
+  Writable
+} from '@flex-development/tutils'
+import type CallSite from '../call-site'
+import type ErrInvalidUrl from '../err-invalid-url'
+import type TestSubject from '../node-error-constructor'
+
+describe('unit-d:interfaces/NodeErrorConstructor', () => {
+  it('should construct NodeError<T>', () => {
+    // Arrange
+    type T = TypeError
+
+    // Expect
+    expectTypeOf<TestSubject<T>>().instance.toEqualTypeOf<NodeError<T>>()
+  })
+
+  it('should match [captureStackTrace(err: Error, ctor?: Fn): void]', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('captureStackTrace')
+      .toEqualTypeOf<(err: Error, ctor?: Fn) => void>()
+  })
+
+  it('should match [prepareStackTrace?(err: Error, traces: CallSite[]): any]', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('prepareStackTrace')
+      .toMatchTypeOf<Optional<Fn<[Error, CallSite[]]>>>()
+  })
+
+  it('should match [readonly prototype: NodeError<T>]', () => {
+    // Arrange
+    type T = ErrInvalidUrl
+    type M = MessageFn<Times<1, string>>
+
+    // Expect
+    expectTypeOf<Pick<TestSubject<T, M>, 'prototype'>>().toEqualTypeOf<{
+      readonly prototype: NodeError<T>
+    }>()
+  })
+
+  it('should match [stackTraceLimit: number]', () => {
+    expectTypeOf<TestSubject>()
+      .toHaveProperty('stackTraceLimit')
+      .toEqualTypeOf<number>()
+  })
+
+  describe('M extends MessageFn', () => {
+    it('should be callable with Parameters<M>', () => {
+      // Arrange
+      type T = RangeError
+      type M = MessageFn<[string, number]>
+
+      // Expect
+      expectTypeOf<TestSubject<T, M>>().constructorParameters.toEqualTypeOf<
+        Parameters<M>
+      >()
+    })
+  })
+
+  describe('M extends readonly unknown[]', () => {
+    it('should be callable with Writable<M>', () => {
+      // Arrange
+      type T = SyntaxError
+      type M = Readonly<Times<2, string>>
+
+      // Expect
+      expectTypeOf<TestSubject<T, M>>().constructorParameters.toEqualTypeOf<
+        Writable<M>
+      >()
+    })
+  })
+
+  describe('M extends string', () => {
+    it('should be callable with any[]', () => {
+      expectTypeOf<TestSubject<TypeError, string>>()
+        .constructorParameters.extract<any[]>()
+        .not.toBeNever()
+    })
+  })
+})

src/interfaces/call-site.ts

@@ -0,0 +1,119 @@
+/**
+ * @file Interfaces - CallSite
+ * @module errnode/interfaces/CallSite
+ */
+
+import type { Fn, Nullable, Optional } from '@flex-development/tutils'
+
+/**
+ * Object representing a stack frame.
+ *
+ * @see https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+ */
+interface CallSite {
+  /**
+   * Returns the current column number of the script the function was defined
+   * in.
+   *
+   * @return {Nullable<number>} Current column number or `null`
+   */
+  getColumnNumber(): Nullable<number>
+
+  /**
+   * Returns a string representing the location where `eval` was called if the
+   * current function was created using a call to `eval`.
+   *
+   * @return {Optional<string>} Location `eval` was called or `undefined`
+   */
+  getEvalOrigin(): Optional<string>
+
+  /**
+   * Returns the name of the script containing the current function if the
+   * function was defined in a script.
+   *
+   * @return {Optional<string>} Parent script name or `undefined`
+   */
+  getFileName(): Optional<string>
+
+  /**
+   * Returns the current function.
+   *
+   * @return {Optional<Fn>} Current function or `undefined`
+   */
+  getFunction(): Optional<Fn>
+
+  /**
+   * Returns the name of the current function, typically its `name` property.
+   *
+   * If a `name` property is not available, an attempt is made to infer a name
+   * from the function’s context.
+   *
+   * @return {Nullable<Fn['name']>} Current function name or `null`
+   */
+  getFunctionName(): Nullable<Fn['name']>
+
+  /**
+   * Returns the current line number of the script the function was defined in.
+   *
+   * @return {Nullable<number>} Current line number or `null`
+   */
+  getLineNumber(): Nullable<number>
+
+  /**
+   * Returns the name of the `this` property or one of its prototypes that holds
+   * the current function.
+   *
+   * @return {Nullable<string>} Property containing current function or `null`
+   */
+  getMethodName(): Nullable<string>
+
+  /**
+   * Returns the value of `this`.
+   *
+   * @template T - `this` type
+   *
+   * @return {T} Value of `this`
+   */
+  getThis<T = unknown>(): T
+
+  /**
+   * Returns the type of `this` as a string.
+   *
+   * This is the name of the function stored in the constructor field of `this`,
+   * if available, otherwise the object’s `[[Class]]` internal property.
+   *
+   * @return {Nullable<string>} Type of `this` as a string or `null`
+   */
+  getTypeName(): Nullable<string>
+
+  /**
+   * Returns a boolean indicating if the current call is a constructor call.
+   *
+   * @return {boolean} `true` if call is constructor call
+   */
+  isConstructor(): boolean
+
+  /**
+   * Returns a boolean indicating if the current call took place in code defined
+   * by a call to `eval`.
+   *
+   * @return {boolean} `true` if call takes place in code defined by `eval`
+   */
+  isEval(): boolean
+
+  /**
+   * Returns a boolean indicating if the current call is in native V8 code.
+   *
+   * @return {boolean} `true` if call is in native V8 code
+   */
+  isNative(): boolean
+
+  /**
+   * Returns a boolean indicating the current call is a top-level invocation.
+   *
+   * @return {boolean} `true` if call is top-level invocation
+   */
+  isToplevel(): boolean
+}
+
+export type { CallSite as default }