yerror 6.2.0 → 7.0.0

package/src/{index.mocha.js → index.test.ts}

@@ -1,11 +1,12 @@
 /* eslint max-nested-callbacks:[0], no-magic-numbers:[0] */
+import { describe, test } from '@jest/globals';
 import assert from 'assert';
-import YError from '.';
+import { YError } from './index.js';
 
 describe('YError', () => {
   describe('.__constructor', () => {
-    it('Should work', () => {
-      var err = new YError('E_ERROR', 'arg1', 'arg2');
+    test('Should work', () => {
+      const err = new YError('E_ERROR', 'arg1', 'arg2');
 
       assert(err instanceof Error);
       assert.equal(err.name, err.toString());
@@ -13,16 +14,16 @@ describe('YError', () => {
       assert.deepEqual(err.params, ['arg1', 'arg2']);
       assert.equal(err.toString(), 'YError: E_ERROR (arg1, arg2)');
     });
-    it('Should work without code', () => {
-      var err = new YError();
+    test('Should work without code', () => {
+      const err = new YError();
 
       assert.equal(err.code, 'E_UNEXPECTED');
       assert.deepEqual(err.params, []);
       assert.equal(err.toString(), 'YError: E_UNEXPECTED ()');
       assert.equal(err.name, err.toString());
     });
-    it('Should work without new', () => {
-      var err = new YError('E_ERROR', 'arg1', 'arg2');
+    test('Should work without new', () => {
+      const err = new YError('E_ERROR', 'arg1', 'arg2');
 
       assert.equal(err.code, 'E_ERROR');
       assert(err instanceof YError);
@@ -33,69 +34,77 @@ describe('YError', () => {
   });
 
   describe('.wrap()', () => {
-    it('Should work with standard errors and a message', () => {
+    test('Should work with standard errors and a message', () => {
       // eslint-disable-line
-      var err = YError.wrap(new Error('This is an error!'));
+      const err = YError.wrap(new Error('This is an error!'));
 
       assert.equal(err.code, 'E_UNEXPECTED');
       assert.equal(err.wrappedErrors.length, 1);
       assert.deepEqual(err.params, ['This is an error!']);
 
-      if (Error.captureStackTrace) {
+      if ('captureStackTrace' in Error) {
         assert(
-          -1 !== err.stack.indexOf('Error: This is an error!'),
+          -1 !== (err.stack || '').indexOf('Error: This is an error!'),
           'Stack contains original error.',
         );
         assert(
-          -1 !== err.stack.indexOf('YError: E_UNEXPECTED (This is an error!)'),
+          -1 !==
+            (err.stack || '').indexOf(
+              'YError: E_UNEXPECTED (This is an error!)',
+            ),
           'Stack contains cast error.',
         );
         assert.equal(err.name, err.toString());
       }
     });
 
-    it('Should work with standard errors and an error code', () => {
-      var err = YError.wrap(new Error('E_ERROR'));
+    test('Should work with standard errors and an error code', () => {
+      const err = YError.wrap(new Error('E_ERROR'));
 
       assert.equal(err.code, 'E_ERROR');
       assert.equal(err.wrappedErrors.length, 1);
       assert.deepEqual(err.params, []);
 
-      if (Error.captureStackTrace) {
+      if ('captureStackTrace' in Error) {
         assert(
-          -1 !== err.stack.indexOf('Error: E_ERROR'),
+          -1 !== (err.stack || '').indexOf('Error: E_ERROR'),
           'Stack contains original error.',
         );
         assert(
-          -1 !== err.stack.indexOf('YError: E_ERROR ()'),
+          -1 !== (err.stack || '').indexOf('YError: E_ERROR ()'),
           'Stack contains cast error.',
         );
       }
       assert.equal(err.name, err.toString());
     });
 
-    it('Should work with standard errors, an error code and params', () => {
-      var err = YError.wrap(new Error('E_ERROR'), 'E_ERROR_2', 'arg1', 'arg2');
+    test('Should work with standard errors, an error code and params', () => {
+      const err = YError.wrap(
+        new Error('E_ERROR'),
+        'E_ERROR_2',
+        'arg1',
+        'arg2',
+      );
 
       assert.equal(err.code, 'E_ERROR_2');
       assert.equal(err.wrappedErrors.length, 1);
       assert.deepEqual(err.params, ['arg1', 'arg2']);
 
-      if (Error.captureStackTrace) {
+      if ('captureStackTrace' in Error) {
         assert(
-          -1 !== err.stack.indexOf('Error: E_ERROR'),
+          -1 !== (err.stack || '').indexOf('Error: E_ERROR'),
           'Stack contains first error.',
         );
         assert(
-          -1 !== err.stack.indexOf('YError: E_ERROR_2 (arg1, arg2)'),
+          -1 !== (err.stack || '').indexOf('YError: E_ERROR_2 (arg1, arg2)'),
           'Stack contains second error.',
         );
       }
       assert.equal(err.name, err.toString());
     });
 
-    it('Should work with several wrapped errors', () => {
-      var err = YError.wrap(
+    test('Should work with several wrapped errors', () => {
+      const err = YError.wrap(
         YError.wrap(new Error('E_ERROR_1'), 'E_ERROR_2', 'arg2.1', 'arg2.2'),
         'E_ERROR_3',
         'arg3.1',
@@ -106,17 +115,19 @@ describe('YError', () => {
       assert.equal(err.wrappedErrors.length, 2);
       assert.deepEqual(err.params, ['arg3.1', 'arg3.2']);
 
-      if (Error.captureStackTrace) {
+      if ('captureStackTrace' in Error) {
         assert(
-          -1 !== err.stack.indexOf('Error: E_ERROR_1'),
+          -1 !== (err.stack || '').indexOf('Error: E_ERROR_1'),
           'Stack contains first error.',
         );
         assert(
-          -1 !== err.stack.indexOf('YError: E_ERROR_2 (arg2.1, arg2.2)'),
+          -1 !==
+            (err.stack || '').indexOf('YError: E_ERROR_2 (arg2.1, arg2.2)'),
           'Stack contains second error.',
         );
         assert(
-          -1 !== err.stack.indexOf('YError: E_ERROR_3 (arg3.1, arg3.2)'),
+          -1 !==
+            (err.stack || '').indexOf('YError: E_ERROR_3 (arg3.1, arg3.2)'),
           'Stack contains second error.',
         );
       }
@@ -125,35 +136,38 @@ describe('YError', () => {
   });
 
   describe('.cast()', () => {
-    it('Should work with standard errors and a message', () => {
-      var err = YError.cast(new Error('This is an error!'));
+    test('Should work with standard errors and a message', () => {
+      const err = YError.cast(new Error('This is an error!'));
 
       assert.equal(err.code, 'E_UNEXPECTED');
       assert.equal(err.wrappedErrors.length, 1);
       assert.deepEqual(err.params, ['This is an error!']);
 
-      if (Error.captureStackTrace) {
+      if ('captureStackTrace' in Error) {
         assert(
-          -1 !== err.stack.indexOf('Error: This is an error!'),
+          -1 !== (err.stack || '').indexOf('Error: This is an error!'),
           'Stack contains original error.',
         );
         assert(
-          -1 !== err.stack.indexOf('YError: E_UNEXPECTED (This is an error!)'),
+          -1 !==
+            (err.stack || '').indexOf(
+              'YError: E_UNEXPECTED (This is an error!)',
+            ),
           'Stack contains cast error.',
         );
       }
       assert.equal(err.name, err.toString());
     });
 
-    it('Should let YError instances pass through', () => {
-      var err = YError.cast(new YError('E_ERROR', 'arg1', 'arg2'));
+    test('Should let YError instances pass through', () => {
+      const err = YError.cast(new YError('E_ERROR', 'arg1', 'arg2'));
 
       assert.equal(err.code, 'E_ERROR');
       assert.deepEqual(err.params, ['arg1', 'arg2']);
 
-      if (Error.captureStackTrace) {
+      if ('captureStackTrace' in Error) {
         assert(
-          -1 !== err.stack.indexOf('YError: E_ERROR (arg1, arg2)'),
+          -1 !== (err.stack || '').indexOf('YError: E_ERROR (arg1, arg2)'),
           'Stack contains cast error.',
         );
       }
@@ -162,54 +176,59 @@ describe('YError', () => {
   });
 
   describe('.bump()', () => {
-    it('Should work with standard errors and a message', () => {
-      var err = YError.bump(new Error('This is an error!'));
+    test('Should work with standard errors and a message', () => {
+      const err = YError.bump(new Error('This is an error!'));
 
       assert.equal(err.code, 'E_UNEXPECTED');
       assert.equal(err.wrappedErrors.length, 1);
       assert.deepEqual(err.params, ['This is an error!']);
 
-      if (Error.captureStackTrace) {
+      if ('captureStackTrace' in Error) {
         assert(
-          -1 !== err.stack.indexOf('Error: This is an error!'),
+          -1 !== (err.stack || '').indexOf('Error: This is an error!'),
           'Stack contains original error.',
         );
         assert(
-          -1 !== err.stack.indexOf('YError: E_UNEXPECTED (This is an error!)'),
+          -1 !==
+            (err.stack || '').indexOf(
+              'YError: E_UNEXPECTED (This is an error!)',
+            ),
           'Stack contains bumped error.',
         );
       }
       assert.equal(err.name, err.toString());
     });
 
-    it('Should work with YError like errors', () => {
-      var baseErr = new Error('E_A_NEW_ERROR');
+    test('Should work with YError like errors', () => {
+      const baseErr = new Error('E_A_NEW_ERROR');
 
-      baseErr.code = 'E_A_NEW_ERROR';
-      baseErr.params = ['baseParam1', 'baseParam2'];
+      (baseErr as YError).code = 'E_A_NEW_ERROR';
+      (baseErr as YError).params = ['baseParam1', 'baseParam2'];
 
-      let err = YError.bump(baseErr);
+      const err = YError.bump(baseErr);
 
       assert.equal(err.code, 'E_A_NEW_ERROR');
       assert.equal(err.wrappedErrors.length, 1);
       assert.deepEqual(err.params, ['baseParam1', 'baseParam2']);
 
-      if (Error.captureStackTrace) {
+      if ('captureStackTrace' in Error) {
         assert(
-          -1 !== err.stack.indexOf('Error: E_A_NEW_ERROR'),
+          -1 !== (err.stack || '').indexOf('Error: E_A_NEW_ERROR'),
           'Stack contains original error.',
         );
         assert(
           -1 !==
-            err.stack.indexOf('YError: E_A_NEW_ERROR (baseParam1, baseParam2)'),
+            (err.stack || '').indexOf(
+              'YError: E_A_NEW_ERROR (baseParam1, baseParam2)',
+            ),
           'Stack contains bumped error.',
         );
       }
       assert.equal(err.name, err.toString());
     });
 
-    it('Should work with Y errors and a message', () => {
-      var err = YError.bump(
+    test('Should work with Y errors and a message', () => {
+      const err = YError.bump(
         new YError('E_ERROR', 'arg1.1', 'arg1.2'),
         'E_ERROR_2',
         'arg2.1',
@@ -219,13 +238,13 @@ describe('YError', () => {
       assert.equal(err.code, 'E_ERROR');
       assert.deepEqual(err.params, ['arg1.1', 'arg1.2']);
 
-      if (Error.captureStackTrace) {
+      if ('captureStackTrace' in Error) {
         assert(
-          -1 !== err.stack.indexOf('YError: E_ERROR (arg1.1, arg1.2)'),
+          -1 !== (err.stack || '').indexOf('YError: E_ERROR (arg1.1, arg1.2)'),
           'Stack contains original error.',
         );
         assert(
-          -1 !== err.stack.indexOf('YError: E_ERROR (arg1.1, arg1.2)'),
+          -1 !== (err.stack || '').indexOf('YError: E_ERROR (arg1.1, arg1.2)'),
           'Stack contains bumped error.',
         );
       }

package/src/index.ts

@@ -0,0 +1,192 @@
+import os from 'os';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type YErrorParams = any;
+
+/**
+ * A YError class able to contain some params and
+ *  print better stack traces
+ * @extends Error
+ */
+class YError extends Error {
+  code: string;
+  params: YErrorParams[];
+  wrappedErrors: (Error | YError)[];
+  /**
+   * Creates a new YError with an error code
+   *  and some params as debug values.
+   * @param {string} [errorCode = 'E_UNEXPECTED']
+   * The error code corresponding to the actual error
+   * @param {...YErrorParams} [params]
+   * Some additional debugging values
+   */
+  constructor(errorCode: string, ...params: YErrorParams[]);
+  constructor(
+    wrappedErrors?: Error[],
+    errorCode?: string,
+    ...params: YErrorParams[]
+  );
+  constructor(wrappedErrors, errorCode, ...params) {
+    // Detecting if wrappedErrors are passed
+    if (!(wrappedErrors instanceof Array)) {
+      params = ('undefined' === typeof errorCode ? [] : [errorCode]).concat(
+        params,
+      );
+      errorCode = wrappedErrors;
+      wrappedErrors = [];
+    }
+
+    // Call the parent constructor
+    super(errorCode);
+
+    // Filling error
+    this.code = errorCode || 'E_UNEXPECTED';
+    this.params = params;
+    this.wrappedErrors = wrappedErrors;
+    this.name = this.toString();
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+
+  /**
+   * Wraps any error and output a YError with an error
+   *  code and some params as debug values.
+   * @param {Error} err
+   * The error to wrap
+   * @param {string} [errorCode = 'E_UNEXPECTED']
+   * The error code corresponding to the actual error
+   * @param {...YErrorParams} [params]
+   * Some additional debugging values
+   * @return {YError}
+   * The wrapped error
+   */
+  static wrap<E extends Error | YError>(
+    err: E,
+    errorCode?: string,
+    ...params: YErrorParams[]
+  ): YError {
+    const wrappedErrorIsACode = _looksLikeAYErrorCode(err.message);
+    const wrappedErrors = (
+      'wrappedErrors' in err ? err.wrappedErrors : []
+    ).concat(err);
+
+    if (!errorCode) {
+      if (wrappedErrorIsACode) {
+        errorCode = err.message;
+      } else {
+        errorCode = 'E_UNEXPECTED';
+      }
+    }
+    if (err.message && !wrappedErrorIsACode) {
+      params.push(err.message);
+    }
+    return new YError(wrappedErrors, errorCode, ...params);
+  }
+
+  /**
+   * Return a YError as is or wraps any other error and output
+   *  a YError with a code and some params as debug values.
+   * @param {Error} err
+   * The error to cast
+   * @param {string} [errorCode = 'E_UNEXPECTED']
+   * The error code corresponding to the actual error
+   * @param {...YErrorParams} [params]
+   * Some additional debugging values
+   * @return {YError}
+   * The wrapped error
+   */
+  static cast<E extends Error | YError>(
+    err: E,
+    errorCode?: string,
+    ...params: YErrorParams[]
+  ): YError {
+    if (_looksLikeAYError(err)) {
+      return err as unknown as YError;
+    }
+    return YError.wrap(err, errorCode, ...params);
+  }
+
+  /**
+   * Same than `YError.wrap()` but preserves the code
+   *  and the debug values of the error if it is
+   *  already an instance of the YError constructor.
+   * @param {Error} err
+   * The error to bump
+   * @param {string} [errorCode = 'E_UNEXPECTED']
+   * The error code corresponding to the actual error
+   * @param {...YErrorParams} [params]
+   * Some additional debugging values
+   * @return {YError}
+   * The wrapped error
+   */
+  static bump<E extends Error | YError>(
+    err: E,
+    errorCode?: string,
+    ...params: YErrorParams[]
+  ): YError {
+    if (_looksLikeAYError(err)) {
+      return YError.wrap(err, (err as YError).code, ...(err as YError).params);
+    }
+    return YError.wrap(err, errorCode, ...params);
+  }
+
+  toString(): string {
+    return (
+      (this.wrappedErrors.length
+        ? // eslint-disable-next-line
+          this.wrappedErrors[this.wrappedErrors.length - 1].stack + os.EOL
+        : '') +
+      this.constructor.name +
+      ': ' +
+      this.code +
+      ' (' +
+      this.params.join(', ') +
+      ')'
+    );
+  }
+}
+
+/**
+ * Allow to print a stack from anything (especially catched
+ *  errors that may or may not contain errors 🤷).
+ * @param {Error} err
+ * The error to print
+ * @return {string}
+ * The stack trace if any
+ */
+export function printStackTrace(err: Error | YError): string {
+  return typeof err === 'object' && typeof err.stack === 'string'
+    ? err.stack
+    : `[no_stack_trace]: error is ${
+        err != null && typeof err.toString === 'function'
+          ? err.toString()
+          : typeof err
+      }`;
+}
+
+// In order to keep compatibility through major versions
+// we have to make kind of an cross major version instanceof
+function _looksLikeAYError(err: Error | YError): boolean {
+  return (
+    !!(err instanceof YError) ||
+    !!(
+      err.constructor &&
+      err.constructor.name &&
+      err.constructor.name.endsWith('Error') &&
+      'code' in err &&
+      'string' === typeof err.code &&
+      _looksLikeAYErrorCode(err.code) &&
+      'params' in err &&
+      err.params &&
+      err.params instanceof Array
+    )
+  );
+}
+
+function _looksLikeAYErrorCode(str: string): boolean {
+  return /^([A-Z0-9_]+)$/.test(str);
+}
+
+export { YError };

package/dist/index.mjs

@@ -1,117 +0,0 @@
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-
-function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
-
-function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-import os from 'os';
-
-let YError = function (_Error) {
-  _inherits(YError, _Error);
-
-  function YError(wrappedErrors, errorCode, ...params) {
-    var _this;
-
-    _classCallCheck(this, YError);
-
-    if (!(wrappedErrors instanceof Array)) {
-      params = ('undefined' === typeof errorCode ? [] : [errorCode]).concat(params);
-      errorCode = wrappedErrors;
-      wrappedErrors = [];
-    }
-
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(YError).call(this, errorCode));
-    _this.code = errorCode || 'E_UNEXPECTED';
-    _this.params = params;
-    _this.wrappedErrors = wrappedErrors;
-    _this.name = _this.toString();
-
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(_assertThisInitialized(_this), _this.constructor);
-    }
-
-    return _this;
-  }
-
-  _createClass(YError, [{
-    key: "toString",
-    value: function toString() {
-      return (this.wrappedErrors.length ? this.wrappedErrors[this.wrappedErrors.length - 1].stack + os.EOL : '') + this.constructor.name + ': ' + this.code + ' (' + this.params.join(', ') + ')';
-    }
-  }]);
-
-  return YError;
-}(_wrapNativeSuper(Error));
-
-YError.wrap = function yerrorWrap(err, errorCode, ...params) {
-  let yError = null;
-
-  const wrappedErrorIsACode = _looksLikeAYErrorCode(err.message);
-
-  const wrappedErrors = (err.wrappedErrors || []).concat(err);
-
-  if (!errorCode) {
-    if (wrappedErrorIsACode) {
-      errorCode = err.message;
-    } else {
-      errorCode = 'E_UNEXPECTED';
-    }
-  }
-
-  if (err.message && !wrappedErrorIsACode) {
-    params.push(err.message);
-  }
-
-  yError = new YError(wrappedErrors, errorCode, ...params);
-  return yError;
-};
-
-YError.cast = function yerrorCast(err, ...params) {
-  if (_looksLikeAYError(err)) {
-    return err;
-  }
-
-  return YError.wrap.apply(YError, [err].concat(params));
-};
-
-YError.bump = function yerrorBump(err, ...params) {
-  if (_looksLikeAYError(err)) {
-    return YError.wrap.apply(YError, [err, err.code].concat(err.params));
-  }
-
-  return YError.wrap.apply(YError, [err].concat(params));
-};
-
-export function printStackTrace(err) {
-  return typeof err === 'object' && typeof err.stack === 'function' ? err.stack() : `[no_stack_trace]: error is ${err != null && typeof err.toString === 'function' ? err.toString() : typeof err}`;
-}
-
-function _looksLikeAYError(err) {
-  return err instanceof YError || err.constructor && err.constructor.name && err.constructor.name.endsWith('Error') && 'string' === typeof err.code && _looksLikeAYErrorCode(err.code) && err.params && err.params instanceof Array;
-}
-
-function _looksLikeAYErrorCode(str) {
-  return /^([A-Z0-9_]+)$/.test(str);
-}
-
-export default YError;
-export { YError };
-//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":["os","YError","wrappedErrors","errorCode","params","Array","concat","code","name","toString","Error","captureStackTrace","constructor","length","stack","EOL","join","wrap","yerrorWrap","err","yError","wrappedErrorIsACode","_looksLikeAYErrorCode","message","push","cast","yerrorCast","_looksLikeAYError","apply","bump","yerrorBump","printStackTrace","endsWith","str","test"],"sources":["../src/index.js"],"sourcesContent":["import os from 'os';\n\n/**\n * An YError class able to contain some params and\n *  print better stack traces\n * @extends Error\n */\nclass YError extends Error {\n  /**\n   * Creates a new YError with an error code\n   *  and some params as debug values.\n   * @param {string} [errorCode = 'E_UNEXPECTED']\n   * The error code corresponding to the actual error\n   * @param {...any} [params]\n   * Some additional debugging values\n   */\n  constructor(wrappedErrors, errorCode, ...params) {\n    // Detecting if wrappedErrors are passed\n    if (!(wrappedErrors instanceof Array)) {\n      params = ('undefined' === typeof errorCode ? [] : [errorCode]).concat(\n        params,\n      );\n      errorCode = wrappedErrors;\n      wrappedErrors = [];\n    }\n\n    // Call the parent constructor\n    super(errorCode);\n\n    // Filling error\n    this.code = errorCode || 'E_UNEXPECTED';\n    this.params = params;\n    this.wrappedErrors = wrappedErrors;\n    this.name = this.toString();\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  }\n\n  toString() {\n    return (\n      (this.wrappedErrors.length\n        ? // eslint-disable-next-line\n          this.wrappedErrors[this.wrappedErrors.length - 1].stack + os.EOL\n        : '') +\n      this.constructor.name +\n      ': ' +\n      this.code +\n      ' (' +\n      this.params.join(', ') +\n      ')'\n    );\n  }\n}\n\n/**\n * Wraps any error and output a YError with an error\n *  code and some params as debug values.\n * @param {Error} err\n * The error to wrap\n * @param {string} [errorCode = 'E_UNEXPECTED']\n * The error code corresponding to the actual error\n * @param {...any} [params]\n * Some additional debugging values\n * @return {YError}\n * The wrapped error\n */\nYError.wrap = function yerrorWrap(err, errorCode, ...params) {\n  let yError = null;\n  const wrappedErrorIsACode = _looksLikeAYErrorCode(err.message);\n  const wrappedErrors = (err.wrappedErrors || []).concat(err);\n\n  if (!errorCode) {\n    if (wrappedErrorIsACode) {\n      errorCode = err.message;\n    } else {\n      errorCode = 'E_UNEXPECTED';\n    }\n  }\n  if (err.message && !wrappedErrorIsACode) {\n    params.push(err.message);\n  }\n  yError = new YError(wrappedErrors, errorCode, ...params);\n  return yError;\n};\n\n/**\n * Return a YError as is or wraps any other error and output\n *  a YError with a code and some params as debug values.\n * @param {Error} err\n * The error to cast\n * @param {string} [errorCode = 'E_UNEXPECTED']\n * The error code corresponding to the actual error\n * @param {...any} [params]\n * Some additional debugging values\n * @return {YError}\n * The wrapped error\n */\nYError.cast = function yerrorCast(err, ...params) {\n  if (_looksLikeAYError(err)) {\n    return err;\n  }\n  return YError.wrap.apply(YError, [err].concat(params));\n};\n\n/**\n * Same than `YError.wrap()` but preserves the code\n *  and the debug values of the error if it is\n *  already an instance of the YError constructor.\n * @param {Error} err\n * The error to bump\n * @param {string} [errorCode = 'E_UNEXPECTED']\n * The error code corresponding to the actual error\n * @param {...any} [params]\n * Some additional debugging values\n * @return {YError}\n * The wrapped error\n */\nYError.bump = function yerrorBump(err, ...params) {\n  if (_looksLikeAYError(err)) {\n    return YError.wrap.apply(YError, [err, err.code].concat(err.params));\n  }\n  return YError.wrap.apply(YError, [err].concat(params));\n};\n\n/**\n * Allow to print a stack from anything (especially catched\n *  errors that may or may not contain errors 🤷).\n * @param {Error} err\n * The error to print\n * @return {string}\n * The stack trace if any\n */\nexport function printStackTrace(err) {\n  return typeof err === 'object' && typeof err.stack === 'function'\n    ? err.stack()\n    : `[no_stack_trace]: error is ${\n        err != null && typeof err.toString === 'function'\n          ? err.toString()\n          : typeof err\n      }`;\n}\n\n// In order to keep compatibility through major versions\n// we have to make kind of an cross major version instanceof\nfunction _looksLikeAYError(err) {\n  return (\n    err instanceof YError ||\n    (err.constructor &&\n      err.constructor.name &&\n      err.constructor.name.endsWith('Error') &&\n      'string' === typeof err.code &&\n      _looksLikeAYErrorCode(err.code) &&\n      err.params &&\n      err.params instanceof Array)\n  );\n}\n\nfunction _looksLikeAYErrorCode(str) {\n  return /^([A-Z0-9_]+)$/.test(str);\n}\n\nexport default YError;\nexport { YError };\n"],"mappings":"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"}