computed-types/lib/schema/errors.js

Runtime validation types for TypeScript.

"use strict";

exports.__esModule = true;
exports.ValidationError = void 0;
exports.createValidationError = createValidationError;
exports.toError = toError;
exports.toPathErrors = toPathErrors;

class ValidationError extends TypeError {
  constructor(message, errors) {
    super(message);
    this.errors = void 0;
    this.path = void 0;
    this.errors = errors; // Extending error in TypeScript:
    // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work

    Object.setPrototypeOf(this, ValidationError.prototype);
  }

  toJSON() {
    var _this$errors;

    return {
      message: this.message,
      errors: (_this$errors = this.errors) == null ? void 0 : _this$errors.map(({
        path,
        error
      }) => {
        var _ValidationError$prot;

        return {
          path,
          error: ((_ValidationError$prot = ValidationError.prototype.toJSON) == null ? void 0 : _ValidationError$prot.apply(error)) || error
        };
      })
    };
  }

}

exports.ValidationError = ValidationError;
ValidationError.prototype.name = 'ValidationError';

function toError(error, ...args) {
  if (typeof error === 'string') {
    return new ValidationError(error);
  }

  if (typeof error === 'function') {
    return toError(error(...args));
  }

  return error;
}

function toPathErrors(errorLike, path) {
  var _error$errors;

  const error = toError(errorLike);

  if (Array.isArray(error.path)) {
    path = error.path;
  }

  if ((_error$errors = error.errors) != null && _error$errors.length) {
    return [].concat(...error.errors.map(item => toPathErrors(item.error, [...path, ...item.path])));
  }

  return [{
    error,
    path
  }];
}

function createValidationError(errors, error, ...args) {
  if (!error) {
    if (errors[0]) {
      const {
        path,
        error: err
      } = errors[0];
      const message = String(err && err.message || err);
      error = path ? `${path.join('.')}: ${message}` : message;
    } else {
      error = 'Unknown Validation Error';
    }
  }

  const err = toError(error, ...args);
  err.errors = errors;
  return err;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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