immediate-error 12.0.0 → 12.2.0

package/README.md

@@ -34,10 +34,12 @@ immediateError("URI Error", ErrorType.URIError) // throws a URIError
 
 immediateError("fruit consumption error", ErrorType.FruitConsumptionError) // throws FruitConsumptionError
 
-immediateError("vegetables cannot talk error", ErrorType.VegetablesCannotTalkError) // throws a VegetablesCannotTalkError
+immediateError("vegetables do not talk error", ErrorType.VegetablesDoNotTalkError) // throws a VegetablesDoNotTalkError
 
 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)
@@ -59,7 +61,7 @@ const TypeErrorConstructor = getError(ErrorType.TypeError)
 
 console.log(TypeErrorConstructor === TypeError) // true
 
-const VegetablesCannotTalkError = getError(ErrorType.VegetablesCannotTalkError)
+const VegetablesDoNotTalkError = getError(ErrorType.VegetablesDoNotTalkError)
 
 try {
   const Vegetable = require("libvegetable")
@@ -67,7 +69,7 @@ try {
 
   vegetable.greet()
 } catch (error) {
-  console.log(error.constructor === VegetablesCannotTalkError) // true
+  console.log(error.constructor === VegetablesDoNotTalkError) // true
 }
 ```
 
@@ -96,6 +98,17 @@ const { delayedError, ErrorType } = require("immediate-error")
 delayedError("delayed", ErrorType.BaseError, 1000) // waits 1000 ms (1 second) and then throws error
 ```
 
+Getting Error Messages:
+```js
+// MESSAGES includes all error messages generally thrown from domain-specic enterprise errors
+const { MESSAGES } = require("immediate-error")
+console.log(MESSAGES.DOMAIN.FRUIT_CONSUMPTION_ERROR.NO_FRUIT_LEFT) // "no fruit left"
+console.log(MESSAGES.DOMAIN.VEGETABLES_DO_NOT_TALK_ERROR.VEGETABLES_CAN_NOT_TALK) // "vegetables can not talk"
+console.log(MESSAGES.DOMAIN.PERSON_NOT_HUNGRY_ERROR.IS_NOT_HUNGRY_AND_CANNOT_BE_FED) // "% is not hungry and cannot be fed"
+console.log(MESSAGES.DOMAIN.PORTIONS_ERROR.PORTION_SIZE_EXPECTED_TO_BE_A_POSITIVE_INTEGER) // "Portion size expected to be a positive integer"
+console.log(MESSAGES.DOMAIN.PORTIONS_ERROR.TOO_MANY_PORTIONS) // "Too many portions"
+```
+
 ## `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:

package/index.d.ts

@@ -7,69 +7,76 @@ export enum ErrorType {
   TypeError = 5,
   URIError = 6,
   FruitConsumptionError = 7,
-  VegetablesCannotTalkError = 8,
+  VegetablesDoNotTalkError = 8,
   PersonNotHungryError = 9,
+  PortionsError = 10,
 }
-
 export type CustomError = {
   new (message: string): Error
 }
-
 export function getError(errorType: ErrorType.BaseError): typeof Error
 export function getError(errorType: ErrorType.EvalError): typeof EvalError
 export function getError(errorType: ErrorType.RangeError): typeof RangeError
 export function getError(
-  errorType: ErrorType.ReferenceError
+  errorType: ErrorType.ReferenceError,
 ): typeof ReferenceError
 export function getError(errorType: ErrorType.SyntaxError): typeof SyntaxError
 export function getError(errorType: ErrorType.TypeError): typeof TypeError
 export function getError(errorType: ErrorType.URIError): typeof URIError
 export function getError(
-  errorType: ErrorType.FruitConsumptionError
+  errorType: ErrorType.FruitConsumptionError,
 ): CustomError
 export function getError(
-  errorType: ErrorType.VegetablesCannotTalkError
+  errorType: ErrorType.VegetablesDoNotTalkError,
 ): 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(
   message?: string,
-  errorType?: ErrorType | CustomError
+  errorType?: ErrorType | CustomError,
 ): never
-
 export function throwWhatever(whateverToThrow: any): never
-
-interface AttemptConstructor {
-  new (handler?: () => void): Attempt
-
-  (handler?: () => void): Attempt
+export const attempt: {
+  new (handler?: () => void): {
+    trycode?: () => void
+    rescuehandler?: (error: any) => void
+    elsehandler?: () => void
+    ensurehandler?: (error: any) => void
+    rescue(handler: (error: any) => void): this
+    else(handler: () => void): this
+    ensure(handler: () => void): this
+    end(): void
+  }
+  (handler?: () => void): {
+    trycode?: () => void
+    rescuehandler?: (error: any) => void
+    elsehandler?: () => void
+    ensurehandler?: (error: any) => void
+    rescue(handler: (error: any) => void): this
+    else(handler: () => void): this
+    ensure(handler: () => void): this
+    end(): void
+  }
 }
-
-declare class Attempt {
-  constructor(handler?: () => void)
-
-  trycode?: () => void
-  rescuehandler?: (error: any) => void
-  elsehandler?: () => void
-  ensurehandler?: (error: any) => void
-
-  rescue(handler: (error: any) => void): this
-  else(handler: () => void): this
-  ensure(handler: () => void): this
-  end(): void
-}
-
-export const attempt: AttemptConstructor
-
 export function delayedError(
   message?: string,
   errorType?: ErrorType | CustomError,
-  delay?: number
+  delay?: number,
 ): Promise<never>
 
-export function delayedError(
-  message: undefined,
-  errorType: undefined,
-  delay: number
-): Promise<never>
+export const MESSAGES: {
+  DOMAIN: {
+    FRUIT_CONSUMPTION_ERROR: { NO_FRUIT_LEFT: "no fruit left" }
+    VEGETABLES_DO_NOT_TALK_ERROR: {
+      VEGETABLES_CAN_NOT_TALK: "vegetables can not talk"
+    }
+    PERSON_NOT_HUNGRY_ERROR: {
+      IS_NOT_HUNGRY_AND_CANNOT_BE_FED: "% is not hungry and cannot be fed"
+    },
+    PORTIONS_ERROR: {
+      PORTION_SIZE_EXPECTED_TO_BE_A_POSITIVE_INTEGER: "Portion size expected to be a positive integer",
+      TOO_MANY_PORTIONS: "Too many portions"
+    }
+  }
+}

package/index.js

@@ -5,11 +5,10 @@
 
 const GetIntrinsic = require("es-intrinsic-cache")
 const SimpleCache = require("simple-lru-cache")
-eval(require("javascript-interpreter"))
-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("noop-enterprise")
@@ -19,7 +18,7 @@ const construct = require("construct-new")
 const toStr = require("@rightpad/convert2string")
 const attempt = require("attempt-statement")
 const trueValue = require("true-value")
-const asArray = require("as-array")
+const asArray = x => [x] // behind bars
 const isString = require("@is-(unknown)/is-string")
 const repeating = require("repeating")
 const deepFreeze = require("deep-freeze-node3") // 3rd iteration of deep-freeze-node, and the only 10x one.
@@ -71,6 +70,8 @@ const isNull = require("@is-(unknown)/is-null")
 const isUndefined = require("@is-(unknown)/is-undefined")
 const isNaN = require("@is-(unknown)/is-nan")
 
+const multiply = require("lolite.__private.multiplyfallback")
+
 const nullvalue = require("primitive-value-null")
 const nanvalue = require("primitive-value-nan")
 const undef = require("primitive-value-undefined")
@@ -89,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")
@@ -122,8 +125,9 @@ const ErrorType = deepFreeze({
   URIError: six,
 
   FruitConsumptionError: seven,
-  VegetablesCannotTalkError: eight,
+  VegetablesDoNotTalkError: eight,
   PersonNotHungryError: nine,
+  PortionsError: ten,
 })
 
 const ErrorMap = construct({
@@ -162,13 +166,16 @@ function createObjectWithTargetKey(value) {
   )
   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 eval(
+    eval(join(array, toStr(target_).substr(twentyNine, six))),
   )
 }
 
+var noFruitLeftMessage
+var vegetablesCanNotTalkMessage
+var personIsNotHungryAndCannotBeFedMessage
+var portionSizeExpectedToBeAPositiveIntegerMessage
+
 objGetMember(
   just,
   "call",
@@ -190,14 +197,11 @@ objGetMember(
       const fruit = construct(createObjectWithTargetKey(Fruit))
       let result
       attempt(() => {
-        fruit
-        eval(require("javascript-interpreter"))
-        interpret = require("javascript-interpreter/interpret")
-
-        interpret(repeating(concat("fruit.eat()", NEWLINE), eleven))
+        eval(repeating(concat("fruit.eat()", NEWLINE), eleven))
       })
         .rescue((error) => {
           result = error.constructor
+          noFruitLeftMessage = error.message
         })
         .else(noop)
         .ensure(noop)
@@ -208,7 +212,7 @@ objGetMember(
   )
 
   ErrorMap.set(
-    ErrorType.VegetablesCannotTalkError,
+    ErrorType.VegetablesDoNotTalkError,
     objGetMember(
       just,
       "call",
@@ -221,6 +225,7 @@ objGetMember(
       })
         .rescue((error) => {
           result = error.constructor
+          vegetablesCanNotTalkMessage = error.message
         })
         .else(noop)
         .ensure(noop)
@@ -245,6 +250,7 @@ objGetMember(
       })
         .rescue((error) => {
           result = error.constructor
+          personIsNotHungryAndCannotBeFedMessage = replaceAll(error.message, "undefined", "%")
         })
         .else(noop)
         .ensure(noop)
@@ -253,6 +259,30 @@ objGetMember(
       return result
     }),
   )
+
+  ErrorMap.set(
+    ErrorType.PortionsError,
+    objGetMember(
+      just,
+      "call",
+    )(function () {
+      let result
+      attempt(() => {
+        construct({
+          target: Guacamole,
+          args: [negative87],
+        })
+      })
+        .rescue((error) => {
+          result = error.constructor
+          portionSizeExpectedToBeAPositiveIntegerMessage = error.message
+        })
+        .else(noop)
+        .ensure(noop)
+        .end()
+      return result
+    }),
+  )
 })
 
 function CreateSleepFunction(delay) {
@@ -297,11 +327,7 @@ exports.immediateError = function immediateError(message, errorType) {
   require("is-not-integer")() // how did we get here?
 }
 
-exports.delayedError = function delayedError(
-  message,
-  errorType,
-  delay,
-) {
+exports.delayedError = function delayedError(message, errorType, delay) {
   message = coalesce(message, default_error)
   errorType = coalesce(errorType, ErrorType.BaseError)
   return objGetMember(call, "then")(
@@ -346,6 +372,35 @@ exports.throwWhatever = function throwWhatever(whateverToThrow) {
   }
 }
 
+var tooManyPortionsMessage
+
+attempt(() => {
+  const guacamole = construct({
+    target: Guacamole,
+    args: [multiply(oneHundred, oneHundred)]
+  })
+}).rescue(error => {
+  tooManyPortionsMessage = error.message
+}).else(noop).ensure(noop).end()
+
+exports.MESSAGES = {
+  DOMAIN: {
+    FRUIT_CONSUMPTION_ERROR: {
+      NO_FRUIT_LEFT: noFruitLeftMessage
+    },
+    VEGETABLES_DO_NOT_TALK_ERROR: {
+      VEGETABLES_CAN_NOT_TALK: vegetablesCanNotTalkMessage
+    },
+    PERSON_NOT_HUNGRY_ERROR: {
+      IS_NOT_HUNGRY_AND_CANNOT_BE_FED: personIsNotHungryAndCannotBeFedMessage
+    },
+    PORTIONS_ERROR: {
+      PORTION_SIZE_EXPECTED_TO_BE_A_POSITIVE_INTEGER: portionSizeExpectedToBeAPositiveIntegerMessage,
+      TOO_MANY_PORTIONS: tooManyPortionsMessage
+    }
+  }
+}
+
 exports.attempt = attempt
 
 exports.ErrorType = ErrorType

package/index.test.js

@@ -1,7 +1,12 @@
-const { immediateError, ErrorType, throwWhatever, getError } = require("./index")
+const {
+  immediateError,
+  ErrorType,
+  throwWhatever,
+  getError,
+  MESSAGES
+} = 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!")
@@ -20,16 +25,17 @@ describe("immediateError utility", () => {
     ["SyntaxError", ErrorType.SyntaxError, SyntaxError],
     ["TypeError", ErrorType.TypeError, TypeError],
     ["URIError", ErrorType.URIError, URIError],
-  ])("throws %s when specified", (name, type, constructor) => {
+  ])("throws % when specified", (name, type, constructor) => {
     expect(() => immediateError("test message", type)).toThrow(constructor)
   })
 
-  test.each([
+ test.each([
     ["FruitConsumptionError", ErrorType.FruitConsumptionError],
-    ["VegetablesCannotTalkError", ErrorType.VegetablesCannotTalkError],
+    ["VegetablesDoNotTalkError", ErrorType.VegetablesDoNotTalkError],
     ["PersonNotHungryError", ErrorType.PersonNotHungryError],
-  ])("throws domain-specific %s correctly", (name, type) => {
-    const expectedConstructor = require("./index").getError(type)
+    ["PortionsError", ErrorType.PortionsError],
+  ])("throws domain-specific % correctly", (name, type) => {
+    const expectedConstructor = getError(type)
     expect(() => immediateError("enterprise failure", type)).toThrow(expectedConstructor)
     expect(() => immediateError("enterprise failure", type)).toThrow("enterprise failure")
   })
@@ -43,7 +49,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 +107,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 +131,7 @@ describe("attempt utility", () => {
     const b = a.rescue(() => {})
     const c = b.else(() => {})
     const d = c.ensure(() => {})
-    
+
     expect(a).toBe(d)
   })
 })
@@ -135,7 +143,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) {
@@ -221,9 +229,27 @@ describe("getError utility", () => {
     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)
   })
-})
+})
+
+describe("error messages", () => {
+  test.each([
+    ["no fruit left", MESSAGES.DOMAIN.FRUIT_CONSUMPTION_ERROR.NO_FRUIT_LEFT],
+    ["vegetables can not talk", MESSAGES.DOMAIN.VEGETABLES_DO_NOT_TALK_ERROR.VEGETABLES_CAN_NOT_TALK],
+    ["% is not hungry and cannot be fed", MESSAGES.DOMAIN.PERSON_NOT_HUNGRY_ERROR.IS_NOT_HUNGRY_AND_CANNOT_BE_FED],
+    ["Portion size expected to be a positive integer", MESSAGES.DOMAIN.PORTIONS_ERROR.PORTION_SIZE_EXPECTED_TO_BE_A_POSITIVE_INTEGER],
+    ["Too many portions", MESSAGES.DOMAIN.PORTIONS_ERROR.TOO_MANY_PORTIONS]
+  ])("provides error message \"%s\" correctly", (a, b) => {
+    expect(a).toEqual(b)
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "immediate-error",
-  "version": "12.0.0",
+  "version": "12.2.0",
   "description": "enterprise errors",
   "main": "index.js",
   "scripts": {
@@ -60,6 +60,7 @@
     "@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",
@@ -70,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",
@@ -84,7 +86,6 @@
     "@uppercase-letters/r": "^3.0.0",
     "array-get-member": "^1.0.3",
     "array.prototype.join": "^1.0.4",
-    "as-array": "^2.0.0",
     "attempt-statement": "^1.2.1",
     "bail": "^1.0.5",
     "basic-functions": "^1.0.6",
@@ -102,11 +103,12 @@
     "get-member": "^1337.69.420",
     "is-": "^1.0.0",
     "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",
+    "lolite.__private.multiplyfallback": "^1.1.17",
     "node-call.then": "^1.0.0",
     "noop-enterprise": "^2.0.1",
     "noop10": "1.0.3",