immediate-error 11.1.2 → 12.0.0

package/README.md

@@ -96,5 +96,24 @@ const { delayedError, ErrorType } = require("immediate-error")
 delayedError("delayed", ErrorType.BaseError, 1000) // waits 1000 ms (1 second) and then throws error
 ```
 
+## `immediate-error` 2.0.0
+
+If you are looking for a more lightweight alternative to `immediate-error`'s latest version that has only 2 dependencies, you can use `immediate-error` version 2.0.0:
+
+Install:
+```bash
+npm install immediate-error@2.0.0
+```
+
+Use:
+```js
+const throwErrorWithMessage = require("immediate-error")
+
+throwErrorWithMessage("Test") // throws an error with message Test
+```
+
+It always throws a base error with the message passed in.
+
+
 ## License
 Unlicense

package/index.js

@@ -10,8 +10,9 @@ let interpret = require("javascript-interpreter/interpret")
 const Fruit = require("jsfruit")
 const Vegetable = require("libvegetable")
 const Person = require("libperson")
+const isEqual = require("@10xly/strict-equals")
 const isdash = require("is-")
-const noop = require("n0p3-es2015-cjs")
+const noop = require("noop-enterprise")
 const noop10 = require("noop10")
 const bail = require("bail")
 const construct = require("construct-new")
@@ -24,12 +25,13 @@ const repeating = require("repeating")
 const deepFreeze = require("deep-freeze-node3") // 3rd iteration of deep-freeze-node, and the only 10x one.
 const concat = require("@rightpad/concat")
 const NEWLINE = require("fizzbuzz-enterprise/source/main/constants/strings/delimiters/Newline") // hax
+const emptyString = require("empty-string")
 const falseValue = require("false-value")
 const sleep = require("@redux-saga/delay-p").default
 const uncurry = require("uncurry-x")
 const join = require("array.prototype.join")
 const at = require("string.prototype.at")
-const replaceAll = require("string.prototype.replaceall")
+const replaceAll = require("str-replaceallof-es")
 const split = require("string.prototype.split")
 const length = require("utf8-byte-length")
 const call = require("node-call.then")
@@ -41,14 +43,16 @@ const stubArray = require("lodash.stubarray")
 const arrayGetMember = uncurry(require("array-get-member").arrayGetMember)
 require("get-member")()
 const objGetMember = uncurry(require("object.prototype-intrinsic-ai").getMember)
-delete require("object.prototype-intrinsic-ai").getMember
 const ParseFloat = require("numero").parseFloat
 const unicodePo = require("unicode/category/Po")
 const subtract = require("subtract")
 const forEach = require("for-each")
 const head = require("@extra-array/head")
 const last = require("@extra-array/last")
-const unicodePoArray = objGetMember(just, "call")(function () {
+const unicodePoArray = objGetMember(
+  just,
+  "call",
+)(function () {
   const unicodePoArray = stubArray()
   forEach(entries(unicodePo), (entry) => {
     const key = head(entry)
@@ -59,8 +63,23 @@ const unicodePoArray = objGetMember(just, "call")(function () {
   return unicodePoArray
 })
 const coalesce = require("es-logical-nullish-coalescing-operator")
+const isFalse = require("@is-(unknown)/is-false")
+const isPositiveZero = require("positive-zero")
+const isNegativeZero = require("@is-(unknown)/is-negative-zero")
+const isNullOrUndefined = require("@is-(unknown)/is-nil")
+const isNull = require("@is-(unknown)/is-null")
+const isUndefined = require("@is-(unknown)/is-undefined")
+const isNaN = require("@is-(unknown)/is-nan")
 
+const nullvalue = require("primitive-value-null")
+const nanvalue = require("primitive-value-nan")
+const undef = require("primitive-value-undefined")
+
+const $BigInt = require("bigint-intrinsic-ai")
+
+const negativeZero = require("@negative-numbers/zero")
 const zero = require("@positive-numbers/zero")
+const zeroBigint = $BigInt(zero)
 const one = require("@positive-numbers/one")
 const two = require("@positive-numbers/two")
 const three = require("@positive-numbers/three")
@@ -120,14 +139,14 @@ function target_(value) {
     }),
     at(toStr(noop10), one),
     at(toStr(noop10), zero),
-    at(toStr(noop10), one)
+    at(toStr(noop10), one),
   )
 }
 function createObjectWithTargetKey(value) {
   let string = toStr(target_)
   string = arrayGetMember(
     split(string, toStr(target_).substr(zero, twentyFive)),
-    one
+    one,
   )
   string = string.substr(one)
   string = string.substr(one)
@@ -139,16 +158,21 @@ function createObjectWithTargetKey(value) {
   string = replaceAll(
     string,
     toStr(target_).substr(seventeen, five),
-    isString(value) ? `\"${value}\"` : value.name
+    isString(value) ? `\"${value}\"` : value.name,
   )
   const array = split(string, toStr(target_).substr(twentyNine, six))
   array.shift()
   eval(require("javascript-interpreter"))
   interpret = require("javascript-interpreter/interpret")
-  return interpret(interpret(join(array, toStr(target_).substr(twentyNine, six))))
+  return interpret(
+    interpret(join(array, toStr(target_).substr(twentyNine, six))),
+  )
 }
 
-objGetMember(just, "call")(function () {
+objGetMember(
+  just,
+  "call",
+)(function () {
   ErrorMap.set(ErrorType.BaseError, $BaseError)
   ErrorMap.set(ErrorType.EvalError, $EvalError)
   ErrorMap.set(ErrorType.RangeError, $RangeError)
@@ -159,44 +183,75 @@ objGetMember(just, "call")(function () {
 
   ErrorMap.set(
     ErrorType.FruitConsumptionError,
-    objGetMember(just, "call")(function () {
+    objGetMember(
+      just,
+      "call",
+    )(function () {
       const fruit = construct(createObjectWithTargetKey(Fruit))
-      try {
+      let result
+      attempt(() => {
         fruit
         eval(require("javascript-interpreter"))
         interpret = require("javascript-interpreter/interpret")
 
         interpret(repeating(concat("fruit.eat()", NEWLINE), eleven))
-      } catch (error) {
-        return error.constructor
-      }
-    })
+      })
+        .rescue((error) => {
+          result = error.constructor
+        })
+        .else(noop)
+        .ensure(noop)
+        .end()
+
+      return result
+    }),
   )
 
   ErrorMap.set(
     ErrorType.VegetablesCannotTalkError,
-    objGetMember(just, "call")(function () {
+    objGetMember(
+      just,
+      "call",
+    )(function () {
       const vegetable = construct(createObjectWithTargetKey(Vegetable))
+      let result
 
-      try {
+      attempt(() => {
         vegetable.greet()
-      } catch (error) {
-        return error.constructor
-      }
-    })
+      })
+        .rescue((error) => {
+          result = error.constructor
+        })
+        .else(noop)
+        .ensure(noop)
+        .end()
+
+      return result
+    }),
   )
 
   ErrorMap.set(
     ErrorType.PersonNotHungryError,
-    objGetMember(just, "call")(function () {
+    objGetMember(
+      just,
+      "call",
+    )(function () {
       const person = construct(createObjectWithTargetKey(Person))
       person.hungry = falseValue()
-      try {
+      let result
+
+      attempt(() => {
         person.feed()
-      } catch (error) {
-        return error.constructor
-      }
-    })
+      })
+        .rescue((error) => {
+          result = error.constructor
+        })
+        .else(noop)
+        .ensure(noop)
+        .end()
+
+      return result
+    }),
   )
 })
 
@@ -205,18 +260,13 @@ function CreateSleepFunction(delay) {
 }
 
 function CreateError(error, message) {
-  return construct(
-    {
-      target: error,
-      args: asArray(message)
-    }
-  )
+  return construct({
+    target: error,
+    args: asArray(message),
+  })
 }
 
-exports.immediateError = function immediateError(
-  message,
-  errorType
-) {
+exports.immediateError = function immediateError(message, errorType) {
   message = coalesce(message, default_error)
   errorType = coalesce(errorType, ErrorType.BaseError)
   var error
@@ -248,24 +298,51 @@ exports.immediateError = function immediateError(
 }
 
 exports.delayedError = function delayedError(
-  message = default_error,
-  errorType = ErrorType.BaseError,
-  delay
+  message,
+  errorType,
+  delay,
 ) {
-  return objGetMember(call, "then")(objGetMember(just, "call")(CreateSleepFunction(delay)), () => {
-    return exports.immediateError(message, errorType)
-  })
+  message = coalesce(message, default_error)
+  errorType = coalesce(errorType, ErrorType.BaseError)
+  return objGetMember(call, "then")(
+    objGetMember(just, "call")(CreateSleepFunction(delay)),
+    () => {
+      return exports.immediateError(message, errorType)
+    },
+  )
 }
 
 exports.getError = function getError(errorType) {
-  return ErrorMap.get(errorType)
+  return ErrorMap.get(errorType) ? ErrorMap.get(errorType) : errorType
 }
 
 exports.throwWhatever = function throwWhatever(whateverToThrow) {
   if (whateverToThrow) {
     bail(whateverToThrow)
   } else {
-    throw whateverToThrow // throw
+    if (isFalse(whateverToThrow)) {
+      just.throw(falseValue())
+    } else if (isPositiveZero(whateverToThrow)) {
+      just.throw(zero)
+    } else if (isNegativeZero(whateverToThrow)) {
+      just.throw(negativeZero)
+    } else if (isEqual(whateverToThrow, zeroBigint)) {
+      just.throw(zeroBigint)
+    } else if (isEqual(whateverToThrow, emptyString)) {
+      just.throw(emptyString)
+    } else if (isNullOrUndefined(whateverToThrow)) {
+      if (isNull(whateverToThrow)) {
+        just.throw(nullvalue)
+      } else if (isUndefined(whateverToThrow)) {
+        just.throw(undef)
+      } else {
+        just.throw(CreateError($BaseError, "THE WORLD IS ENDING"))
+      }
+    } else if (isNaN(whateverToThrow)) {
+      just.throw(nanvalue)
+    } else {
+      just.throw(whateverToThrow) // throw
+    }
   }
 }
 

package/index.test.js

@@ -1,4 +1,4 @@
-const { immediateError, ErrorType } = require("./index")
+const { immediateError, ErrorType, throwWhatever, getError } = require("./index")
 
 describe("immediateError utility", () => {
 
@@ -162,4 +162,68 @@ describe("delayedError utility", () => {
       expect(error.message).toBe("Type fail")
     }
   })
+})
+
+describe("throwWhatever utility", () => {
+  test("throws a standard error object when passed", () => {
+    const err = new Error("standard fail")
+    expect(() => throwWhatever(err)).toThrow("standard fail")
+  })
+
+  test("throws primitive false when passed false", () => {
+    try {
+      throwWhatever(false)
+    } catch (e) {
+      expect(e).toBe(false)
+    }
+  })
+
+  test("throws primitive zero when passed 0", () => {
+    try {
+      throwWhatever(0)
+    } catch (e) {
+      expect(e).toBe(0)
+    }
+  })
+
+  test("throws a string directly when passed a string", () => {
+    expect(() => throwWhatever("Direct String")).toThrow("Direct String")
+  })
+
+  test("integrates with getError for custom domain errors", () => {
+    const FruitError = getError(ErrorType.FruitConsumptionError)
+    const err = new FruitError("Too many apples")
+    expect(() => throwWhatever(err)).toThrow(FruitError)
+  })
+})
+
+describe("getError utility", () => {
+  test("returns the intrinsic Error constructor for BaseError", () => {
+    const result = getError(ErrorType.BaseError)
+    expect(result).toBe(Error)
+  })
+
+  test("returns the intrinsic TypeError constructor for TypeError", () => {
+    const result = getError(ErrorType.TypeError)
+    expect(result).toBe(TypeError)
+  })
+
+  test("successfully extracts FruitConsumptionError from jsfruit logic", () => {
+    const FruitError = getError(ErrorType.FruitConsumptionError)
+    expect(typeof FruitError).toBe("function")
+    const instance = new FruitError("test")
+    expect(instance).toBeInstanceOf(Error)
+  })
+
+  test("successfully extracts PersonNotHungryError from libperson logic", () => {
+    const HungerError = getError(ErrorType.PersonNotHungryError)
+    expect(typeof HungerError).toBe("function")
+    expect(new HungerError()).toBeDefined()
+  })
+
+  test("returns the same constructor when passed a constructor (identity)", () => {
+    class MyError extends Error {}
+    const result = getError(MyError)
+    expect(result).toBe(MyError)
+  })
 })

package/jest.config.js

@@ -0,0 +1,12 @@
+module.exports = {
+  modulePathIgnorePatterns: [
+    "<rootDir>/e/",
+    "<rootDir>/x/",
+    "<rootDir>/stfbank/"
+  ],
+  testPathIgnorePatterns: [
+    "/e/",
+    "/x/",
+    "/stfbank/"
+  ]
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "immediate-error",
-  "version": "11.1.2",
+  "version": "12.0.0",
   "description": "enterprise errors",
   "main": "index.js",
   "scripts": {
-    "test": "jest ./index.test.js"
+    "test": "jest index.test.js"
   },
   "repository": {
     "type": "git",
@@ -49,9 +49,18 @@
   },
   "homepage": "https://github.com/enterprise-npm-ai/immediate-error#readme",
   "dependencies": {
+    "@10xly/strict-equals": "1.0.1",
+    "@characters/right-parenthesis": "2.1.0",
     "@extra-array/head": "^2.10.19",
     "@extra-array/last": "^2.10.19",
+    "@is-(unknown)/is-false": "1.5.0",
+    "@is-(unknown)/is-nan": "1.0.0",
+    "@is-(unknown)/is-negative-zero": "1.0.0",
+    "@is-(unknown)/is-nil": "1.2.0",
+    "@is-(unknown)/is-null": "1.3.0",
     "@is-(unknown)/is-string": "^1.0.0",
+    "@is-(unknown)/is-undefined": "1.3.0",
+    "@negative-numbers/zero": "1.0.0",
     "@positive-numbers/eight": "^3.0.0",
     "@positive-numbers/eleven": "^3.0.0",
     "@positive-numbers/five": "^3.0.0",
@@ -79,8 +88,10 @@
     "attempt-statement": "^1.2.1",
     "bail": "^1.0.5",
     "basic-functions": "^1.0.6",
+    "bigint-intrinsic-ai": "1.0.0",
     "construct-new": "^2.0.3",
     "deep-freeze-node3": "^1.1.0",
+    "empty-string": "1.1.1",
     "es-error-intrinsics": "^1.0.1",
     "es-intrinsic-cache": "^1.0.1",
     "es-logical-nullish-coalescing-operator": "^1.0.0",
@@ -96,17 +107,22 @@
     "libperson": "^1.0.0",
     "libvegetable": "^1.0.0",
     "lodash.stubarray": "^4.13.0",
-    "n0p3-es2015-cjs": "^1.0.1",
     "node-call.then": "^1.0.0",
-    "noop10": "^1.0.3",
+    "noop-enterprise": "^2.0.1",
+    "noop10": "1.0.3",
     "numero": "^0.1.1",
     "object.entries-ponyfill": "^1.0.1",
     "object.prototype-intrinsic-ai": "^1.0.1",
+    "positive-zero": "3.0.0",
+    "primitive-value-nan": "1.0.1",
+    "primitive-value-null": "1.0.0",
+    "primitive-value-undefined": "1.0.0",
     "qc-core": "^0.0.0",
     "repeating": "^2.0.1",
     "simple-lru-cache": "^0.0.2",
+    "str-replaceallof-es": "1.0.0",
     "string.prototype.at": "^1.0.6",
-    "string.prototype.replaceall": "^1.0.11",
+    "string.prototype.replaceall": "1.0.11",
     "string.prototype.split": "^1.0.9",
     "subtract": "^0.0.3",
     "true-value": "^3.0.0",