immediate-error 9.0.1 → 10.0.0

package/CHANGELOG.md

@@ -6,6 +6,10 @@ Noitce: ai generated this changelog, so it might not be completely accurate.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [10.0.0]
+### Added
+- Domain specific errors: `FruitConsumptionError`, `VegetablesCannotTalkError`, and `PersonNotHungryError`
+
 ## [9.0.1]
 ### Changed
 - This changelog

package/README.md

@@ -30,6 +30,14 @@ immediateError("Syntax error", ErrorType.SyntaxError) // throws a SyntaxError
 
 immediateError("URI Error", ErrorType.URIError) // throws a URIError
 
+// Domain-specific Enterprise Errors:
+
+immediateError("fruit consumption error", ErrorType.FruitConsumptionError) // throws FruitConsumptionError
+
+immediateError("vegetables cannot talk error", ErrorType.VegetablesCannotTalkError) // throws a VegetablesCannotTalkError
+
+immediateError("person not hungry error", ErrorType.PersonNotHungryError) // throws a PersonNotHungryError
+
 class MyCustomError extends Error {
   constructor (message) {
     super("Custom: " + message)
@@ -47,6 +55,17 @@ const { getError, ErrorType } = require("immediate-error")
 const TypeErrorConstructor = getError(ErrorType.TypeError)
 
 console.log(TypeErrorConstructor === TypeError) // true
+
+const VegetablesCannotTalkError = getError(ErrorType.VegetablesCannotTalkError)
+
+try {
+  const Vegetable = require("libvegetable")
+  const vegetable = new Vegetable()
+
+  vegetable.greet()
+} catch (error) {
+  console.log(error.constructor === VegetablesCannotTalkError) // true
+}
 ```
 
 ### Changelog

package/index.d.ts

@@ -5,16 +5,16 @@ export enum ErrorType {
   ReferenceError = 3,
   SyntaxError = 4,
   TypeError = 5,
-  URIError = 6
+  URIError = 6,
+  FruitConsumptionError = 7,
+  VegetablesCannotTalkError = 8,
+  PersonNotHungryError = 9
 }
 
 export type CustomError = {
   new (message: string): Error
 }
 
-/**
- * Enterprise retrieval signatures for specific ErrorTypes
- */
 export function getError(errorType: ErrorType.BaseError): typeof Error
 export function getError(errorType: ErrorType.EvalError): typeof EvalError
 export function getError(errorType: ErrorType.RangeError): typeof RangeError
@@ -22,9 +22,12 @@ export function getError(errorType: ErrorType.ReferenceError): typeof ReferenceE
 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): CustomError
+export function getError(errorType: ErrorType.FruitConsumptionError): CustomError
+export function getError(errorType: ErrorType.VegetablesCannotTalkError): CustomError
+export function getError(errorType: ErrorType.PersonNotHungryError): CustomError
+export function getError(errorType: ErrorType | CustomError): CustomError
 
 export function immediateError(
-  message: string, 
+  message?: string, 
   errorType?: ErrorType | CustomError
 ): never

package/index.js

@@ -2,15 +2,21 @@
 
 const GetIntrinsic = require("es-intrinsic-cache")
 const SimpleCache = require("simple-lru-cache")
+const Fruit = require("jsfruit")
+const Vegetable = require("libvegetable")
+const Person = require("libperson")
 const isdash = require("is-")
 const noop = require("n0p3-es2015-cjs")
 const bail = require("bail")
-const vm = require("node:vm")
 const construct = require("construct-new")
 const attempt = require("attempt-statement")
 const trueValue = require("true-value")
 const asArray = require("as-array")
+const repeating = require("repeating")
 const deepFreeze = require("deep-freeze-node3") // 3rd iteration of deep-freeze-node.
+const concat = require("@rightpad/concat")
+const NEWLINE = require("fizzbuzz-enterprise/source/main/constants/strings/delimiters/Newline")
+const falseValue = require("false-value")
 
 const zero = require("@positive-numbers/zero")
 const one = require("@positive-numbers/one")
@@ -19,14 +25,16 @@ const three = require("@positive-numbers/three")
 const four = require("@positive-numbers/four")
 const five = require("@positive-numbers/five")
 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 eleven = require("@positive-numbers/eleven")
 const oneHundred = require("@positive-numbers/one-hundred")
 
 const E = require("@uppercase-letters/e")
 const O = require("@uppercase-letters/o")
 const R = require("@uppercase-letters/r")
 
-const concat = require("@rightpad/concat")
-
 const $BaseError = require("es-error-intrinsics/Error")
 const $EvalError = require("es-error-intrinsics/EvalError")
 const $RangeError = require("es-error-intrinsics/RangeError")
@@ -47,6 +55,10 @@ const ErrorType = deepFreeze({
   SyntaxError: four,
   TypeError: five,
   URIError: six,
+
+  FruitConsumptionError: seven,
+  VegetablesCannotTalkError: eight,
+  PersonNotHungryError: nine
 })
 
 const ErrorMap = construct({
@@ -62,6 +74,37 @@ const ErrorMap = construct({
   ErrorMap.set(ErrorType.SyntaxError, $SyntaxError)
   ErrorMap.set(ErrorType.TypeError, $TypeError)
   ErrorMap.set(ErrorType.URIError, $URIError)
+
+  ErrorMap.set(ErrorType.FruitConsumptionError, (function() {
+    const fruit = construct({ target: Fruit })
+    try {
+      fruit
+
+      eval(repeating(concat("fruit.eat()", NEWLINE), eleven))
+    } catch (error) { 
+      return error.constructor
+    }
+  })())
+
+  ErrorMap.set(ErrorType.VegetablesCannotTalkError, (function() {
+    const vegetable = construct({ target: Vegetable })
+
+    try {
+      vegetable.greet()
+    } catch (error) {
+      return error.constructor
+    }
+  })())
+
+  ErrorMap.set(ErrorType.PersonNotHungryError, (function() {
+    const person = construct({ target: Person })
+    person.hungry = falseValue()
+    try {
+      person.feed()
+    } catch (error) { 
+      return error.constructor
+    }
+  })())
 })()
 
 function CreateError(error, message) {
@@ -95,19 +138,9 @@ exports.immediateError = function immediateError(
     captureStackTrace(error, immediateError)
   }
 
-  const context = {
-    error: error,
-    bail: bail,
-  }
-
-  vm.createContext(context)
-
-  const script = construct({
-    target: vm.Script,
-    args: ["bail(error)", { filename: default_error }],
-  })
+  bail(error)
 
-  script.runInContext(context)
+  require("is-not-integer")() // how did we get here?
 }
 
 exports.getError = function getError(errorType) {

package/index.test.js

@@ -1,32 +1,45 @@
-const { immediateError, ErrorType } = require('./index')
+const { immediateError, ErrorType } = require("./index")
 
-describe('immediateError utility', () => {
+describe("immediateError utility", () => {
 
   // Basic Usage
-  test('throws a regular Error with default message when no arguments are passed', () => {
+  test("throws a regular Error with default message when no arguments are passed", () => {
     expect(() => immediateError()).toThrow(Error)
-    expect(() => immediateError()).toThrow('ERROR!')
+    expect(() => immediateError()).toThrow("ERROR!")
   })
 
-  test('throws a regular Error with a custom message', () => {
-    expect(() => immediateError('Aaaaah')).toThrow(Error)
-    expect(() => immediateError('Aaaaah')).toThrow('Aaaaah')
+  test("throws a regular Error with a custom message", () => {
+    expect(() => immediateError("Aaaaah")).toThrow(Error)
+    expect(() => immediateError("Aaaaah")).toThrow("Aaaaah")
   })
 
   // Native Error Types
   test.each([
-    ['BaseError', ErrorType.BaseError, Error],
-    ['EvalError', ErrorType.EvalError, EvalError],
-    ['RangeError', ErrorType.RangeError, RangeError],
-    ['ReferenceError', ErrorType.ReferenceError, ReferenceError],
-    ['SyntaxError', ErrorType.SyntaxError, SyntaxError],
-    ['TypeError', ErrorType.TypeError, TypeError],
-    ['RangeError', ErrorType.URIError, URIError],
-  ])('throws %s when specified', (name, type, constructor) => {
-    expect(() => immediateError('test message', type)).toThrow(constructor)
+    ["BaseError", ErrorType.BaseError, Error],
+    ["EvalError", ErrorType.EvalError, EvalError],
+    ["RangeError", ErrorType.RangeError, RangeError],
+    ["ReferenceError", ErrorType.ReferenceError, ReferenceError],
+    ["SyntaxError", ErrorType.SyntaxError, SyntaxError],
+    ["TypeError", ErrorType.TypeError, TypeError],
+    ["URIError", ErrorType.URIError, URIError],
+  ])("throws %s when specified", (name, type, constructor) => {
+    expect(() => immediateError("test message", type)).toThrow(constructor)
   })
+
+  // Enterprise Domain-Specific Error Types
+  test.each([
+    ["FruitConsumptionError", ErrorType.FruitConsumptionError],
+    ["VegetablesCannotTalkError", ErrorType.VegetablesCannotTalkError],
+    ["PersonNotHungryError", ErrorType.PersonNotHungryError],
+  ])("throws domain-specific %s correctly", (name, type) => {
+    // We check that it throws an instance of the constructor cached in ErrorMap
+    const expectedConstructor = require("./index").getError(type)
+    expect(() => immediateError("enterprise failure", type)).toThrow(expectedConstructor)
+    expect(() => immediateError("enterprise failure", type)).toThrow("enterprise failure")
+  })
+
   // Custom Error Classes
-  test('throws a custom user-defined Error class', () => {
+  test("throws a custom user-defined Error class", () => {
     class MyCustomError extends Error {
       constructor(message) {
         super("Custom: " + message)
@@ -34,7 +47,17 @@ describe('immediateError utility', () => {
       }
     }
 
-    expect(() => immediateError('Error!', MyCustomError)).toThrow(MyCustomError)
-    expect(() => immediateError('Error!', MyCustomError)).toThrow('Custom: Error!')
+    expect(() => immediateError("Error!", MyCustomError)).toThrow(MyCustomError)
+    expect(() => immediateError("Error!", MyCustomError)).toThrow("Custom: Error!")
+  })
+
+  // Stack Trace Integrity
+  test("captures stack trace correctly and hides internal frames", () => {
+    try {
+      immediateError("stack check")
+    } catch (error) {
+      // The first line of the stack should be the caller, not immediateError itself
+      expect(error.stack).not.toMatch(/at immediateError/)
+    }
   })
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "immediate-error",
-  "version": "9.0.1",
+  "version": "10.0.0",
   "description": "throw errors",
   "main": "index.js",
   "scripts": {
@@ -49,10 +49,14 @@
   },
   "homepage": "https://github.com/enterprise-npm-ai/immediate-error#readme",
   "dependencies": {
+    "@positive-numbers/eight": "^3.0.0",
+    "@positive-numbers/eleven": "^3.0.0",
     "@positive-numbers/five": "^3.0.0",
     "@positive-numbers/four": "^3.0.0",
+    "@positive-numbers/nine": "^3.0.0",
     "@positive-numbers/one": "^3.0.0",
     "@positive-numbers/one-hundred": "^3.0.0",
+    "@positive-numbers/seven": "^3.0.0",
     "@positive-numbers/six": "^3.0.0",
     "@positive-numbers/three": "^3.0.0",
     "@positive-numbers/two": "^3.0.0",
@@ -68,9 +72,16 @@
     "deep-freeze-node3": "^1.1.0",
     "es-error-intrinsics": "^1.0.1",
     "es-intrinsic-cache": "^1.0.1",
+    "false-value": "^2.0.6",
+    "fizzbuzz-enterprise": "^1.0.0",
     "is-": "^1.0.0",
+    "is-not-integer": "^1.0.2",
+    "jsfruit": "^1.1.0",
+    "libperson": "^1.0.0",
+    "libvegetable": "^1.0.0",
     "n0p3-es2015-cjs": "^1.0.1",
     "number-zero": "^1.0.3",
+    "repeating": "^2.0.1",
     "simple-lru-cache": "^0.0.2",
     "true-value": "^2.0.5"
   },