immediate-error 6.3.0 → 6.4.0

package/README.md

@@ -1,6 +1,13 @@
-# Immediate-error
+# `immediate-error`
 
-This is a utility to throw an error.
+This is a utility to throw an error in FP.
+
+## Installation
+```bash
+$ npm install immediate-error
+```
+
+## Usage
 
 ```javascript
 
@@ -35,14 +42,5 @@ class MyCustomError extends Error {
 immediateError('Error!', MyCustomError) // throws a MyCustomError with the message "Error!" which in turn prints out "Custom: Error!" because we used our own error class
 
 ```
-
-## Why?
-
-This module is great because it uses the best practices in JavaScript such as using dependencies like [`yanoop`](https://npmjs.com/package/yanoop) to throw errors and using [`es-errors`](https://npmjs.com/package/es-errors) instead of using the error classes natively.
-
-## why?
-why not
-
-## Show your support
-
-[Follow me on GitHub](https://github.com/tj-commits) and star my repositories.
+## License
+Unlicense

package/index.d.ts

@@ -9,4 +9,11 @@ export enum ErrorType {
   NativeAssertionError = 7
 }
 
-export function immediateError(message?: string, errorType?: ErrorType | Function): void
+export type CustomError = {
+  new (message: string): never
+}
+
+export function immediateError(
+  message: string, 
+  errorType?: ErrorType | CustomError
+): never

package/index.js

@@ -1,99 +1,79 @@
-require('vanilla-javascript')
-require('none')()
-
-const GetIntrinsic = require('get-intrinsic')
-const zero = require('number-zero')
-const one = require('the-number-one').default
-const two = require('two')
-const three = require('numeric-constant-three')
-const four = require('always-four')
-const five = require('five')
-const six = require('number-six') // 6 
-const seven = require('se7en') // 7
-const { throwop } = require('yanoop')
-const isError = require('is-error')
-const assert = require('assert-fn')
-const nativeAssert = require('node:assert')
-const vm = require('node:vm')
-const hasSelfEquality = require('has-self-equality')
-
-const $BaseError = require('es-errors')
+const GetIntrinsic = require("get-intrinsic")
+const $Object = require("es-object-atoms")
+const zero = require("@positive-numbers/zero")
+const one = require("@positive-numbers/one")
+const two = require("@positive-numbers/two")
+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 { 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 $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 $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 default_error = 'ERROR!'
+const default_error = "ERROR!"
 
-const ERROR = Object.freeze({
+const ErrorType = $Object.freeze({
   BaseError: zero,
   AssertionError: one,
-  AggregateError: two(),
-  RangeError: three(),
-  ReferenceError: four(),
-  SyntaxError: five(),
-  TypeError: six(),
-  NativeAssertionError: seven()
+  AggregateError: two,
+  RangeError: three,
+  ReferenceError: four,
+  SyntaxError: five,
+  TypeError: six,
+  NativeAssertionError: seven
 })
 
-exports.immediateError = function immediateError(message = default_error, errorType = ERROR.Error) {
+exports.immediateError = function immediateError(message = default_error, errorType = ErrorType.BaseError) {
   var error
 
-  if (hasSelfEquality(isError)) {
-    switch (errorType) {
-      case ERROR.BaseError: {
-        error = new $BaseError(message)
-        break
-      }
-
-      case ERROR.AssertionError: {
-        error = new $AssertionError(message)
-        break
-      }
-
-      case ERROR.AggregateError: {
-        error = new $AggregateError(message)
-        break
-      }
-
-      case ERROR.RangeError: {
-        error = new $RangeError(message)
-        break
-      }
-
-      case ERROR.ReferenceError: {
-        error = new $ReferenceError(message)
-        break
-      }
-
-      case ERROR.SyntaxError: {
-        error = new $SyntaxError(message)
-        break
-      }
-
-      case ERROR.TypeError: {
-        error = new $TypeError(message)
-        break
-      }
-
-      case ERROR.NativeAssertionError: {
-        error = new $NativeAssertionError(message)
-        break
-      }
-
-      default: {
-        try {
-          error = new errorType(message)
-        } catch (err) {
-          [err] // put the error behind bars, where it belongs
-          error = new $BaseError(message)
-        }
-      }
-    }
-  }
+  Switch(errorType)
+    .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.RangeError, function () {
+      error = construct({ target: $RangeError, args: [message] })
+    })
+    .case(ErrorType.ReferenceError, function () {
+      error = construct({ target: $ReferenceError, args: [message] })
+    })
+    .case(ErrorType.SyntaxError, function () {
+      error = construct({ target: $SyntaxError, args: [message] })
+    })
+    .case(ErrorType.TypeError, function () {
+      error = construct({ target: $TypeError, args: [message] })
+    })
+    .case(ErrorType.NativeAssertionError, function () {
+      error = construct({ target: $NativeAssertionError, args: [message] })
+    })
+    .else(function () {
+      attempt(function() {
+        error = construct({ target: errorType, args: [message] })
+      }).rescue(function() {
+        error = construct({ target: $BaseError, args: [message] })
+      }).else(noop).ensure(noop).end()
+    })
+    .execute()
 
   const context = {
     error,
@@ -101,9 +81,9 @@ exports.immediateError = function immediateError(message = default_error, errorT
   }
   vm.createContext(context)
 
-  const script = new vm.Script(`throwop(error)`, { filename: default_error })
+  const script = construct({ target: vm.Script, args: [`throwop(error)`, { filename: default_error }] })
 
   script.runInContext(context)
 }
 
-exports.ErrorType = ERROR
+exports.ErrorType = ErrorType

package/index.test.js

@@ -0,0 +1,46 @@
+const { immediateError, ErrorType } = require('immediate-error')
+const assert = require('node:assert')
+
+describe('immediateError utility', () => {
+
+  // Basic Usage
+  test('throws a regular Error with default message when no arguments are passed', () => {
+    expect(() => immediateError()).toThrow(Error)
+    expect(() => immediateError()).toThrow('ERROR!')
+  })
+
+  test('throws a regular Error with a custom message', () => {
+    expect(() => immediateError('Aaaaah')).toThrow(Error)
+    expect(() => immediateError('Aaaaah')).toThrow('Aaaaah')
+  })
+
+  // Native Error Types
+  test.each([
+    ['RangeError', ErrorType.RangeError, RangeError],
+    ['ReferenceError', ErrorType.ReferenceError, ReferenceError],
+    ['SyntaxError', ErrorType.SyntaxError, SyntaxError],
+    ['TypeError', ErrorType.TypeError, TypeError],
+    ['AggregateError', ErrorType.AggregateError, AggregateError],
+  ])('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 {
+      constructor(message) {
+        super("Custom: " + message)
+        this.name = "MyCustomError"
+      }
+    }
+
+    expect(() => immediateError('Error!', MyCustomError)).toThrow(MyCustomError)
+    expect(() => immediateError('Error!', MyCustomError)).toThrow('Custom: Error!')
+  })
+})

package/package.json

@@ -1,43 +1,75 @@
 {
   "name": "immediate-error",
-  "version": "6.3.0",
-  "description": "Throw errors, better.",
+  "version": "6.4.0",
+  "description": "throw errors in fp",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest index.test.js"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tj-commits/immediate-error.git"
+    "url": "git+https://github.com/in-fp/immediate-error.git"
   },
   "keywords": [
     "error",
     "throw",
     "immediate-error",
-    "tool"
+    "tool",
+    "10x'ness",
+    "10x'ly made",
+    "10x",
+    "10x-engineer",
+    "10x engineer",
+    "10x engineering",
+    "jsfruit",
+    "libperson",
+    "libvegetable",
+    "bail",
+    "throw-error",
+    "fox",
+    "sigma",
+    "lifesaver",
+    "framework",
+    "js",
+    "ecmascript",
+    "javascript",
+    "licensed",
+    "unlicensed-licensed-license",
+    "jest",
+    "67",
+    "fp",
+    "in-fp",
+    "sigmaskibidi",
+    "tj-commits",
+    "skibidi-toilet-hacker",
+    "stevelib"
   ],
-  "author": "tj-commits",
+  "author": "10x'ly Made",
   "license": "Unlicense",
   "bugs": {
-    "url": "https://github.com/tj-commits/immediate-error/issues"
+    "url": "https://github.com/in-fp/immediate-error/issues"
   },
-  "homepage": "https://github.com/tj-commits/immediate-error#readme",
+  "homepage": "https://github.com/in-fp/immediate-error#readme",
   "dependencies": {
-    "always-four": "^1.0.0",
+    "@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",
+    "construct-new": "^2.0.3",
     "es-errors": "^1.3.0",
-    "five": "^0.8.0",
-    "get-intrinsic": "^1.3.0",
-    "has-self-equality": "^0.0.1",
-    "is-error": "^2.2.2",
-    "none": "^1.0.0",
-    "number-six": "^1.0.1",
+    "es-object-atoms": "^1.1.1",
+    "get-intrinsic": "^1.3.1",
     "number-zero": "^1.0.3",
-    "numeric-constant-three": "^1.0.0",
-    "se7en": "^1.0.0",
-    "the-number-one": "^1.0.1",
-    "two": "^1.0.7",
-    "vanilla-javascript": "^1.1.1",
+    "switch-in-fp": "^3.0.0",
     "yanoop": "^1.0.0"
+  },
+  "devDependencies": {
+    "jest": "^30.2.0"
   }
 }