@hi18n/core/dist/errors.mjs

Message internationalization meets immutability and type-safety - core runtime

import _defineProperty from "@babel/runtime/helpers/defineProperty";

/**
 * An error for a specific message. It is thrown when:
 *
 * - the message is missing,
 * - the message contains a syntax error, or
 * - the message cannot be evaluated with the supplied parameters.
 *
 * @since 0.1.7 (`@hi18n/core`)
 */
export class MessageError extends Error {
  constructor(options) {
    var _this$cause;

    const {
      locale,
      id,
      ...restOptions
    } = options;
    const inLocale = locale != null ? " in ".concat(locale) : "";
    super("Error translating ".concat(id).concat(inLocale, ": ").concat(options.cause.message), restOptions);

    _defineProperty(this, "cause", void 0);

    _defineProperty(this, "locale", void 0);

    _defineProperty(this, "id", void 0);

    this.locale = locale;
    this.id = id;
    (_this$cause = this.cause) !== null && _this$cause !== void 0 ? _this$cause : this.cause = options.cause;
  }

}
/**
 * Missing translation. Usually wrapped in {@link MessageError}.
 *
 * @since 0.1.7 (`@hi18n/core`)
 */

MessageError.prototype.name = "MessageError";
export class MissingTranslationError extends Error {
  constructor() {
    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "Missing translation";
    let options = arguments.length > 1 ? arguments[1] : undefined;
    super(message, options);
  }

}
/**
 * No locale specified.
 *
 * @since 0.1.7 (`@hi18n/core`)
 */

MissingTranslationError.prototype.name = "MissingTranslationError";
export class NoLocaleError extends Error {
  constructor() {
    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "No locale specified";
    let options = arguments.length > 1 ? arguments[1] : undefined;
    super(message, options);
  }

}
/**
 * Locale is specified, but no such locale exists in the book.
 *
 * @since 0.1.7 (`@hi18n/core`)
 */

NoLocaleError.prototype.name = "NoLocaleError";
export class MissingLocaleError extends Error {
  constructor(options) {
    const {
      locale,
      availableLocales,
      ...restOptions
    } = options;
    super("Missing locale: ".concat(locale), restOptions);

    _defineProperty(this, "locale", void 0);

    _defineProperty(this, "availableLocales", void 0);

    this.locale = locale;
    this.availableLocales = availableLocales;
  }

}
/**
 * Parse error. Usually wrapped in {@link MessageError}.
 *
 * @since 0.1.7 (`@hi18n/core`)
 */

MissingLocaleError.prototype.name = "MissingLocaleError";
export class ParseError extends Error {}
/**
 * An error during evaluating messages. Usually wrapped in {@link MessageError}.
 *
 * @since 0.1.7 (`@hi18n/core`)
 */

ParseError.prototype.name = "ParseError";
export class MessageEvaluationError extends Error {}
/**
 * Missing translation argument. Usually wrapped in {@link MessageError}.
 *
 * @since 0.1.7 (`@hi18n/core`)
 */

MessageEvaluationError.prototype.name = "MessageEvaluationError";
export class MissingArgumentError extends MessageEvaluationError {
  constructor(options) {
    const {
      argName,
      ...restOptions
    } = options;
    super("Missing argument: ".concat(argName), restOptions);

    _defineProperty(this, "argName", void 0);

    this.argName = argName;
  }

}
/**
 * Translation argument type mismatch. Usually wrapped in {@link MessageError}.
 *
 * @since 0.1.7 (`@hi18n/core`)
 */

MissingArgumentError.prototype.name = "MissingArgumentError";
export class ArgumentTypeError extends MessageEvaluationError {
  constructor(options) {
    const {
      argName,
      expectedType,
      got,
      ...restOptions
    } = options;
    super( // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
    "Invalid argument ".concat(argName, ": expected ").concat(expectedType, ", got ").concat(got), restOptions);

    _defineProperty(this, "argName", void 0);

    _defineProperty(this, "expectedType", void 0);

    _defineProperty(this, "got", void 0);

    this.argName = argName;
    this.expectedType = expectedType;
    this.got = got;
  }

}
ArgumentTypeError.prototype.name = "ArgumentTypeError";
//# sourceMappingURL=errors.mjs.map