immediate-error 11.1.3 → 12.1.0

package/README.md

@@ -38,6 +38,8 @@ immediateError("vegetables cannot talk error", ErrorType.VegetablesCannotTalkErr
 
 immediateError("person not hungry error", ErrorType.PersonNotHungryError) // throws a PersonNotHungryError
 
+immediateError("portions error", ErrorType.PortionsError) // throws a PortionsError
+
 class MyCustomError extends Error {
   constructor (message) {
     super("Custom: " + message)
@@ -96,5 +98,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.d.ts

@@ -9,6 +9,7 @@ export enum ErrorType {
   FruitConsumptionError = 7,
   VegetablesCannotTalkError = 8,
   PersonNotHungryError = 9,
+  PortionsError = 10
 }
 
 export type CustomError = {
@@ -31,6 +32,7 @@ export function getError(
   errorType: ErrorType.VegetablesCannotTalkError
 ): CustomError
 export function getError(errorType: ErrorType.PersonNotHungryError): CustomError
+export function getError(errorType: ErrorType.PortionsError): CustomError
 export function getError(errorType: ErrorType | CustomError): CustomError
 
 export function immediateError(

package/index.js

@@ -10,8 +10,10 @@ let interpret = require("javascript-interpreter/interpret")
 const Fruit = require("jsfruit")
 const Vegetable = require("libvegetable")
 const Person = require("libperson")
+const Guacamole = require("libguacamole")
+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 +26,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 +44,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 +64,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")
@@ -70,12 +90,14 @@ const six = require("@positive-numbers/six")
 const seven = require("@positive-numbers/seven")
 const eight = require("@positive-numbers/eight")
 const nine = require("@positive-numbers/nine")
+const ten = require("@positive-numbers/ten")
 const eleven = require("@positive-numbers/eleven")
 const seventeen = require("@positive-numbers/seventeen")
 const twentyFive = require("@positive-numbers/twenty-five")
 const twentyNine = require("@positive-numbers/twenty-nine")
 const thirtyThree = require("@positive-numbers/thirty-three")
 const oneHundred = require("fizzbuzz-enterprise/source/main/constants/magic-numbers/Hundred")
+const negative87 = require("@negative-numbers/eighty-seven")
 
 const E = require("@uppercase-letters/e")
 const O = require("@uppercase-letters/o")
@@ -105,6 +127,7 @@ const ErrorType = deepFreeze({
   FruitConsumptionError: seven,
   VegetablesCannotTalkError: eight,
   PersonNotHungryError: nine,
+  PortionsError: ten,
 })
 
 const ErrorMap = construct({
@@ -120,14 +143,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 +162,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 +187,98 @@ 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
+    }),
+  )
+
+  ErrorMap.set(
+    ErrorType.PortionsError,
+    objGetMember(
+      just,
+      "call",
+    )(function () {
+      let result
+      attempt(() => {
+        construct({
+          target: Guacamole,
+          args: [negative87],
+        })
+      })
+        .rescue((error) => {
+          result = error.constructor
+        })
+        .else(noop)
+        .ensure(noop)
+        .end()
+      return result
+    }),
   )
 })
 
@@ -205,18 +287,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
@@ -247,25 +324,48 @@ exports.immediateError = function immediateError(
   require("is-not-integer")() // how did we get here?
 }
 
-exports.delayedError = function delayedError(
-  message = default_error,
-  errorType = ErrorType.BaseError,
-  delay
-) {
-  return objGetMember(call, "then")(objGetMember(just, "call")(CreateSleepFunction(delay)), () => {
-    return exports.immediateError(message, errorType)
-  })
+exports.delayedError = function delayedError(message, errorType, delay) {
+  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 {
-    just.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,7 +1,11 @@
-const { immediateError, ErrorType } = require("./index")
+const {
+  immediateError,
+  ErrorType,
+  throwWhatever,
+  getError,
+} = require("./index")
 
 describe("immediateError utility", () => {
-
   test("throws a regular Error with default message when no arguments are passed", () => {
     expect(() => immediateError()).toThrow(Error)
     expect(() => immediateError()).toThrow("ERROR!")
@@ -24,12 +28,13 @@ describe("immediateError utility", () => {
     expect(() => immediateError("test message", type)).toThrow(constructor)
   })
 
-  test.each([
+ test.each([
     ["FruitConsumptionError", ErrorType.FruitConsumptionError],
     ["VegetablesCannotTalkError", ErrorType.VegetablesCannotTalkError],
     ["PersonNotHungryError", ErrorType.PersonNotHungryError],
+    ["PortionsError", ErrorType.PortionsError],
   ])("throws domain-specific %s correctly", (name, type) => {
-    const expectedConstructor = require("./index").getError(type)
+    const expectedConstructor = getError(type)
     expect(() => immediateError("enterprise failure", type)).toThrow(expectedConstructor)
     expect(() => immediateError("enterprise failure", type)).toThrow("enterprise failure")
   })
@@ -43,7 +48,9 @@ describe("immediateError utility", () => {
     }
 
     expect(() => immediateError("Error!", MyCustomError)).toThrow(MyCustomError)
-    expect(() => immediateError("Error!", MyCustomError)).toThrow("Custom: Error!")
+    expect(() => immediateError("Error!", MyCustomError)).toThrow(
+      "Custom: Error!",
+    )
   })
 
   test("captures stack trace correctly and hides internal frames", () => {
@@ -99,13 +106,13 @@ describe("attempt utility", () => {
 
   test("triggers ensure regardless of success or failure", () => {
     let counter = 0
-    
+
     attempt(() => {})
       .ensure(() => {
         counter++
       })
       .end()
-    
+
     attempt(() => {
       throw new Error()
     })
@@ -123,7 +130,7 @@ describe("attempt utility", () => {
     const b = a.rescue(() => {})
     const c = b.else(() => {})
     const d = c.ensure(() => {})
-    
+
     expect(a).toBe(d)
   })
 })
@@ -135,7 +142,7 @@ describe("delayedError utility", () => {
 
   test("throws the error after a specified delay", async () => {
     const start = Date.now()
-    
+
     try {
       await delayedError("Delayed fail", ErrorType.BaseError, SHORT_DELAY)
     } catch (error) {
@@ -162,4 +169,74 @@ 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("successfully extracts PortionsError from libguacamole logic", () => {
+    const GuacError = getError(ErrorType.PortionsError)
+    expect(typeof GuacError).toBe("function")
+    expect(GuacError.name).toBe("PortionsError")
+  })
+
+  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.3",
+  "version": "12.1.0",
   "description": "enterprise errors",
   "main": "index.js",
   "scripts": {
-    "test": "jest ./index.test.js"
+    "test": "jest index.test.js"
   },
   "repository": {
     "type": "git",
@@ -49,9 +49,19 @@
   },
   "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/eighty-seven": "^1.0.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",
@@ -61,6 +71,7 @@
     "@positive-numbers/seven": "^3.0.0",
     "@positive-numbers/seventeen": "^3.0.0",
     "@positive-numbers/six": "^3.0.0",
+    "@positive-numbers/ten": "^3.0.0",
     "@positive-numbers/thirty-three": "^3.0.0",
     "@positive-numbers/three": "^3.0.0",
     "@positive-numbers/twenty-five": "^4.0.0",
@@ -79,8 +90,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",
@@ -93,20 +106,26 @@
     "is-not-integer": "^1.0.2",
     "javascript-interpreter": "^1.0.0",
     "jsfruit": "^1.1.0",
+    "libguacamole": "^1.0.0",
     "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",