immediate-error 6.4.0 → 7.1.0

package/README.md

@@ -19,12 +19,6 @@ immediateError('Aaaaah') // this will throw a regular Error with the message "Aa
 
 immediateError('Aaaaah', ErrorType.BaseError) // does the same thing as above
 
-immediateError('Aggregate error', ErrorType.AggregateError) // throws an AggregateError
-
-immediateError('Assertion error', ErrorType.AssertionError) // throws an AssertionError (from the assert-fn module)
-
-immediateError('Assertion error', ErrorType.NativeAssertionError) // throws an AssertionError (from the node:assert module)
-
 immediateError('Range error', ErrorType.RangeError) // throws a RangeError
 
 immediateError('Reference error', ErrorType.ReferenceError) // throws a ReferenceError

package/index.d.ts

@@ -1,12 +1,11 @@
 export enum ErrorType {
   BaseError = 0,
-  AggregateError = 1,
-  AssertionError = 2,
-  RangeError = 3,
-  ReferenceError = 4,
-  SyntaxError = 5,
-  TypeError = 6,
-  NativeAssertionError = 7
+  EvalError = 1,
+  RangeError = 2,
+  ReferenceError = 3,
+  SyntaxError = 4,
+  TypeError = 5,
+  URIError = 6
 }
 
 export type CustomError = {

package/index.js

@@ -1,4 +1,4 @@
-const GetIntrinsic = require("get-intrinsic")
+const GetIntrinsic = require("es-intrinsic-cache")
 const $Object = require("es-object-atoms")
 const zero = require("@positive-numbers/zero")
 const one = require("@positive-numbers/one")
@@ -7,35 +7,34 @@ const three = require("@positive-numbers/three")
 const four = require("@positive-numbers/four")
 const five = require("@positive-numbers/five")
 const six = require("@positive-numbers/six")
-const seven = require("@positive-numbers/seven")
-const { throwop, noop } = require("yanoop")
+const noop = require("yanoop").noop
+const bail = require("bail")
 const { Switch } = require("switch-in-fp")
-const assert = require("assert-fn")
-const nativeAssert = require("node:assert")
 const vm = require("node:vm")
 const construct = require("construct-new")
 const attempt = require("attempt-statement")
+const trueValue = require("true-value")
 
-const $BaseError = require("es-errors")
-const $AssertionError = assert.AssertionError
-const $AggregateError = GetIntrinsic("%AggregateError%")
-const $RangeError = require("es-errors/range")
-const $ReferenceError = require("es-errors/ref")
-const $SyntaxError = require("es-errors/syntax")
-const $TypeError = require("es-errors/type")
-const $NativeAssertionError = nativeAssert.AssertionError
+const $BaseError = require("es-error-intrinsics/Error")
+const $EvalError = require("es-error-intrinsics/EvalError")
+const $RangeError = require("es-error-intrinsics/RangeError")
+const $ReferenceError = require("es-error-intrinsics/ReferenceError")
+const $SyntaxError = require("es-error-intrinsics/SyntaxError")
+const $TypeError = require("es-error-intrinsics/TypeError")
+const $URIError = require("es-error-intrinsics/URIError")
+
+const captureStackTrace = GetIntrinsic("%Error.captureStackTrace%", trueValue())
 
 const default_error = "ERROR!"
 
 const ErrorType = $Object.freeze({
   BaseError: zero,
-  AssertionError: one,
-  AggregateError: two,
-  RangeError: three,
-  ReferenceError: four,
-  SyntaxError: five,
-  TypeError: six,
-  NativeAssertionError: seven
+  EvalError: one,
+  RangeError: two,
+  ReferenceError: three,
+  SyntaxError: four,
+  TypeError: five,
+  URIError: six,
 })
 
 exports.immediateError = function immediateError(message = default_error, errorType = ErrorType.BaseError) {
@@ -45,11 +44,8 @@ exports.immediateError = function immediateError(message = default_error, errorT
     .case(ErrorType.BaseError, function () {
       error = construct({ target: $BaseError, args: [message] })
     })
-    .case(ErrorType.AssertionError, function () {
-      error = construct({ target: $AssertionError, args: [message] })
-    })
-    .case(ErrorType.AggregateError, function () {
-      error = construct({ target: $AggregateError, args: [message] })
+    .case(ErrorType.EvalError, function () {
+      error = construct({ target: $EvalError, args: [message] })
     })
     .case(ErrorType.RangeError, function () {
       error = construct({ target: $RangeError, args: [message] })
@@ -63,25 +59,30 @@ exports.immediateError = function immediateError(message = default_error, errorT
     .case(ErrorType.TypeError, function () {
       error = construct({ target: $TypeError, args: [message] })
     })
-    .case(ErrorType.NativeAssertionError, function () {
-      error = construct({ target: $NativeAssertionError, args: [message] })
+    .case(ErrorType.URIError, function () {
+      error = construct({ target: $URIError, args: [message] })
     })
     .else(function () {
-      attempt(function() {
+      attempt(function () {
         error = construct({ target: errorType, args: [message] })
-      }).rescue(function() {
+      }).rescue(function () {
         error = construct({ target: $BaseError, args: [message] })
       }).else(noop).ensure(noop).end()
     })
     .execute()
 
+  if (captureStackTrace) {
+    captureStackTrace(error, immediateError)
+  }
+
   const context = {
-    error,
-    throwop
+    error: error,
+    bail: bail
   }
+
   vm.createContext(context)
 
-  const script = construct({ target: vm.Script, args: [`throwop(error)`, { filename: default_error }] })
+  const script = construct({ target: vm.Script, args: [`bail(error)`, { filename: default_error }] })
 
   script.runInContext(context)
 }

package/index.test.js

@@ -1,4 +1,4 @@
-const { immediateError, ErrorType } = require('immediate-error')
+const { immediateError, ErrorType } = require('./index')
 const assert = require('node:assert')
 
 describe('immediateError utility', () => {
@@ -16,21 +16,16 @@ describe('immediateError utility', () => {
 
   // Native Error Types
   test.each([
+    ['BaseError', ErrorType.BaseError, Error],
+    ['EvalError', ErrorType.EvalError, EvalError],
     ['RangeError', ErrorType.RangeError, RangeError],
     ['ReferenceError', ErrorType.ReferenceError, ReferenceError],
     ['SyntaxError', ErrorType.SyntaxError, SyntaxError],
     ['TypeError', ErrorType.TypeError, TypeError],
-    ['AggregateError', ErrorType.AggregateError, AggregateError],
+    ['RangeError', ErrorType.URIError, URIError],
   ])('throws %s when specified', (name, type, constructor) => {
     expect(() => immediateError('test message', type)).toThrow(constructor)
   })
-
-  // Assertion Errors
-  test('throws NativeAssertionError (node:assert)', () => {
-    expect(() => immediateError('failed', ErrorType.NativeAssertionError))
-      .toThrow(assert.AssertionError)
-  })
-
   // Custom Error Classes
   test('throws a custom user-defined Error class', () => {
     class MyCustomError extends Error {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "immediate-error",
-  "version": "6.4.0",
+  "version": "7.1.0",
   "description": "throw errors in fp",
   "main": "index.js",
   "scripts": {
@@ -26,7 +26,6 @@
     "libvegetable",
     "bail",
     "throw-error",
-    "fox",
     "sigma",
     "lifesaver",
     "framework",
@@ -34,7 +33,6 @@
     "ecmascript",
     "javascript",
     "licensed",
-    "unlicensed-licensed-license",
     "jest",
     "67",
     "fp",
@@ -54,19 +52,19 @@
     "@positive-numbers/five": "^3.0.0",
     "@positive-numbers/four": "^3.0.0",
     "@positive-numbers/one": "^3.0.0",
-    "@positive-numbers/seven": "^3.0.0",
     "@positive-numbers/six": "^3.0.0",
     "@positive-numbers/three": "^3.0.0",
     "@positive-numbers/two": "^3.0.0",
     "@positive-numbers/zero": "^3.0.0",
-    "assert-fn": "^1.0.1",
     "attempt-statement": "^1.2.0",
+    "bail": "^1.0.5",
     "construct-new": "^2.0.3",
-    "es-errors": "^1.3.0",
+    "es-error-intrinsics": "^1.0.1",
+    "es-intrinsic-cache": "^1.0.1",
     "es-object-atoms": "^1.1.1",
-    "get-intrinsic": "^1.3.1",
     "number-zero": "^1.0.3",
     "switch-in-fp": "^3.0.0",
+    "true-value": "^2.0.5",
     "yanoop": "^1.0.0"
   },
   "devDependencies": {