immediate-error 3.1.3 → 4.0.0

package/README.md

@@ -4,24 +4,46 @@ This is a utility to throw an error.
 
 ```javascript
 
-const immediateError = require('immediate-error')
+const { immediateError, ErrorType } = require('immediate-error')
 
-const { ERROR } = immediateError
+immediateError() // this will throw a regular Error with the default message of "ERROR!"
 
-immediateError('Aaaaah') // this will throw an error with the message Aaaaah
+immediateError('Aaaaah') // this will throw a regular Error with the message "Aaaaah"
 
-immediateError('Aaaaah', { errorType: ERROR.Error }) // does the same thing as above because by default errorType is ERROR.Error
+immediateError('Aaaaah', ErrorType.BaseError) // does the same thing as above
 
-immediateError('Assertion error', { errorType: ERROR.AssertionError }) // throws an assertionerror
+immediateError('Assertion error', ErrorType.AssertionError) // throws an AssertionError (from the assert-fn module)
 
-immediateError('Range error', { errorType: ERROR.RangeError }) // throws a rangeerror
+immediateError('Assertion error', ErrorType.NativeAssertionError) // throws an AssertionError (from the node:assert module)
 
-immediateError('Reference error', { errorType: ERROR.ReferenceError }) // throws a referenceerror
+immediateError('Range error', ErrorType.RangeError) // throws a RangeError
 
-immediateError('Syntax error', { errorType: ERROR.SyntaxError }) // throws a syntaxerror
+immediateError('Reference error', ErrorType.ReferenceError) // throws a ReferenceError
 
-immediateError('type error', { errorType: ERROR.TypeError }) // throws a typeerror
+immediateError('Syntax error', ErrorType.SyntaxError) // throws a SyntaxError
 
-immediateError('fucking error', { errorType: ERROR.FuckingError }) // throws a fuckingerror
+immediateError('type error', ErrorType.TypeError) // throws a TypeError
 
-```
+class MyCustomError extends Error {
+  constructor (message) {
+    super("Custom: " + message)
+  }
+}
+
+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 [`throw-error`](https://npmjs.com/package/throw-error) and [`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.
+
+## Show your support
+
+[Follow me on GitHub](https://github.com/tj-commits) and star my repositories.
+
+## is this a joke?
+
+Of course not!
+<br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br>
+(Yes, it is.)

package/index.d.ts

@@ -0,0 +1,11 @@
+export enum ErrorType {
+  BaseError = 0,
+  AssertionError = 1,
+  RangeError = 2,
+  ReferenceError = 3,
+  SyntaxError = 4,
+  TypeError = 5,
+  NativeAssertionError = 6
+}
+
+export function immediateError(message?: string, errorType?: ErrorType | Function): void

package/index.js

@@ -2,88 +2,92 @@ require('vanilla-javascript')
 require('vapor-js-npm')
 require('none')()
 
-const one = require('the-number-one').default // number one
-const two = require('two') // no2 
-const three = require('numeric-constant-three') //no3
-const four = require('always-four') //no4
-const five = require('five') //no5
-const six = require('number-six') //no6
-const successor = require('successor') // + 1
-global.jQuery = require('jquery')
-require('jquery-basic-arithmetic-plugin') // why not use jquery for math?
-const $ = jQuery // define jquery
-const { throwop } = require('yanoop') // throwop
-const throwError = require('throw-error') // nothing wrong with having another way to throw an error
-const If = require('if') // conditional chaining for javascript
+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')
+const { throwop } = require('yanoop')
+const throwError = require('throw-error')
+const If = require('if')
 const clc = require('cli-color')
+const isError = require('is-error')
+const assert = require('assert-fn')
+const nativeAssert = require('node:assert')
+const vm = require('node:vm')
+
+const $BaseError = require('es-errors')
+const $AssertionError = assert.AssertionError
+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 ERROR = Object.freeze({
-   Error:0,
+   BaseError:0,
    AssertionError: one,
    RangeError: two(),
    ReferenceError: three(),
    SyntaxError: four(),
    TypeError: five(),
-   FuckingError: six()
+   NativeAssertionError: six()
 })
 
-class FuckingError extends Error {
-   
-   constructor(message) {
-      super(`FuckingError: Holy shit there was A Fucking Error With A Message: ${message}`)
-   }
-}
-
-const assert = require('assert-fn') // import assert
-const vm = require('node:vm') // vm
-
-module.exports = function immediateError(message = 'YOU SUCK AT PROGRAMMING THERE WAS A FUCKING ERROR!', options = {
-   errorType: ERROR.Error
-}) {
-   var error = new Error(message) /* create an error
-   variable and then use switch statement to set it*/
-   switch(options.errorType) {
-      case ERROR.Error: {
-         error = new Error(message)
-         break
-      }
-
-      case ERROR.AssertionError: {
-         error = new assert.AssertionError(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
-      }
+exports.immediateError = function immediateError(message = 'ERROR!', errorType = ERROR.Error) {
+   var error
 
-      case ERROR.FuckingError: {
-         error = new FuckingError(message)
-         break
-      }
+   if (isError == isError) {
+      switch (errorType) {
+         case ERROR.BaseError: {
+            error = new $BaseError(message)
+            break
+         }
+   
+         case ERROR.AssertionError: {
+            error = new $AssertionError(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
+         }
 
-      default: {
-         error = new Error(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)
+            }
+         }
       }
+   } else {
+      void 0
    }
-   // make a vm context
+
    const context = {
       error,
       throwError,
@@ -93,15 +97,18 @@ module.exports = function immediateError(message = 'YOU SUCK AT PROGRAMMING THER
       console,
       clc
    }
-   vm.createContext(context) // Contextify the object.
+   vm.createContext(context)
+
    const script = new vm.Script(`
    If(rand < 0.3).Then(() => {
       throwError(error)
    }).Else().If(rand > 0.3).Then(() => {
-   throwop(error)
-}).Else(() => {
-   throw error
-})`, { filename: `YOU SUCK AT PROGRAMMING THERE WAS AN ERROR!`})
+      throwop(error)
+   }).Else(() => {
+      throw error
+   })`, { filename: `ERROR!`})
+
    script.runInContext(context)
 }
-module.exports.ERROR = ERROR
+
+exports.ErrorType = ERROR

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "immediate-error",
-  "version": "3.1.3",
+  "version": "4.0.0",
   "description": "Immediate-error",
   "main": "index.js",
   "scripts": {
@@ -26,14 +26,13 @@
     "always-four": "^1.0.0",
     "assert-fn": "^1.0.1",
     "cli-color": "^2.0.4",
+    "es-errors": "^1.3.0",
     "five": "^0.8.0",
     "if": "^2.0.0",
-    "jquery": "^3.7.1",
-    "jquery-basic-arithmetic-plugin": "^1.1.0",
+    "is-error": "^2.2.2",
     "none": "^1.0.0",
     "number-six": "^1.0.1",
     "numeric-constant-three": "^1.0.0",
-    "successor": "^1.0.1",
     "the-number-one": "^1.0.1",
     "throw-error": "^1.0.0",
     "two": "^1.0.7",