immediate-error 12.1.0 → 12.2.0

package/README.md

@@ -34,7 +34,7 @@ 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
 
@@ -61,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")
@@ -69,7 +69,7 @@ try {
 
   vegetable.greet()
 } catch (error) {
-  console.log(error.constructor === VegetablesCannotTalkError) // true
+  console.log(error.constructor === VegetablesDoNotTalkError) // true
 }
 ```
 
@@ -98,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,71 +7,76 @@ export enum ErrorType {
   TypeError = 5,
   URIError = 6,
   FruitConsumptionError = 7,
-  VegetablesCannotTalkError = 8,
+  VegetablesDoNotTalkError = 8,
   PersonNotHungryError = 9,
-  PortionsError = 10
+  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,8 +5,6 @@
 
 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")
@@ -20,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.
@@ -72,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")
@@ -125,7 +125,7 @@ const ErrorType = deepFreeze({
   URIError: six,
 
   FruitConsumptionError: seven,
-  VegetablesCannotTalkError: eight,
+  VegetablesDoNotTalkError: eight,
   PersonNotHungryError: nine,
   PortionsError: ten,
 })
@@ -166,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",
@@ -194,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)
@@ -212,7 +212,7 @@ objGetMember(
   )
 
   ErrorMap.set(
-    ErrorType.VegetablesCannotTalkError,
+    ErrorType.VegetablesDoNotTalkError,
     objGetMember(
       just,
       "call",
@@ -225,6 +225,7 @@ objGetMember(
       })
         .rescue((error) => {
           result = error.constructor
+          vegetablesCanNotTalkMessage = error.message
         })
         .else(noop)
         .ensure(noop)
@@ -249,6 +250,7 @@ objGetMember(
       })
         .rescue((error) => {
           result = error.constructor
+          personIsNotHungryAndCannotBeFedMessage = replaceAll(error.message, "undefined", "%")
         })
         .else(noop)
         .ensure(noop)
@@ -273,6 +275,7 @@ objGetMember(
       })
         .rescue((error) => {
           result = error.constructor
+          portionSizeExpectedToBeAPositiveIntegerMessage = error.message
         })
         .else(noop)
         .ensure(noop)
@@ -369,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

@@ -3,6 +3,7 @@ const {
   ErrorType,
   throwWhatever,
   getError,
+  MESSAGES
 } = require("./index")
 
 describe("immediateError utility", () => {
@@ -24,16 +25,16 @@ 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([
     ["FruitConsumptionError", ErrorType.FruitConsumptionError],
-    ["VegetablesCannotTalkError", ErrorType.VegetablesCannotTalkError],
+    ["VegetablesDoNotTalkError", ErrorType.VegetablesDoNotTalkError],
     ["PersonNotHungryError", ErrorType.PersonNotHungryError],
     ["PortionsError", ErrorType.PortionsError],
-  ])("throws domain-specific %s correctly", (name, type) => {
+  ])("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")
@@ -240,3 +241,15 @@ describe("getError utility", () => {
     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.1.0",
+  "version": "12.2.0",
   "description": "enterprise errors",
   "main": "index.js",
   "scripts": {
@@ -86,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",
@@ -104,12 +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",