@pedrohb/errors 0.0.0-stage → 1.0.0

package/dist/errors-DrDL51y9.mjs

@@ -0,0 +1,149 @@
+//#region src/upper-snake-case.ts
+/**
+* Expressão regular que valida códigos em UPPER_SNAKE_CASE em tempo de
+* execução.
+*
+* Regras (espelham o tipo {@link IsUpperSnakeCase}):
+* - deve começar com uma letra maiúscula (`A-Z`);
+* - pode conter letras maiúsculas, dígitos e `_`;
+* - `_` só pode aparecer entre caracteres alfanuméricos, ou seja, não pode
+*   estar no início nem no fim e não pode ser repetido em sequência.
+*/
+const UPPER_SNAKE_CASE = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
+/**
+* Verifica em tempo de execução, se uma string está em UPPER_SNAKE_CASE.
+*
+* É o equivalente em runtime do tipo {@link IsUpperSnakeCase}, usando a
+* expressão regular {@link UPPER_SNAKE_CASE}.
+*
+* @param value - String a ser verificada.
+* @returns `true` se `value` estiver em UPPER_SNAKE_CASE; caso contrário,
+* `false`.
+*
+* @example
+* ```ts
+* isUpperSnakeCase("USER_NOT_FOUND"); // true
+* isUpperSnakeCase("ERROR_404");      // true
+* isUpperSnakeCase("userNotFound");   // false
+* isUpperSnakeCase("_USER");          // false
+* isUpperSnakeCase("USER__NOT");      // false
+* isUpperSnakeCase("1ERROR");         // false
+* ```
+*/
+function isUpperSnakeCase(value) {
+	return UPPER_SNAKE_CASE.test(value);
+}
+/**
+* Monta a mensagem de erro exibida quando um código não está em
+* UPPER_SNAKE_CASE.
+*
+* O retorno é tipado como {@link InvalidCodeMessage}, de modo que o texto em
+* runtime corresponde exatamente ao tipo literal usado na validação em tempo
+* de compilação.
+*
+* @template Code - Tipo literal do código inválido.
+* @param code - Código de erro inválido a ser incluído na mensagem.
+* @returns Mensagem descrevendo o código inválido e o formato esperado.
+*
+* @example
+* ```ts
+* invalidCodeMessage("userNotFound");
+* // 'Código de erro inválido "userNotFound". Os códigos de erro devem usar UPPER_SNAKE_CASE.'
+* ```
+*/
+function invalidCodeMessage(code) {
+	return `Código de erro inválido "${code}". Os códigos de erro devem usar UPPER_SNAKE_CASE.`;
+}
+//#endregion
+//#region src/errors/invalid-error-code.ts
+/**
+* Erro lançado quando um código de erro não está em UPPER_SNAKE_CASE.
+*
+* Estende `TypeError` pois indica um valor de tipo ou formato inadequado.
+* É lançado em tempo de execução por `defineErrorCatalog` complementando a
+* validação feita em tempo de compilação por `ValidateErrorDefinitions`.
+*
+* A mensagem é gerada por {@link invalidCodeMessage} e o código inválido fica
+* disponível na propriedade `code`.
+*
+* O `name` do erro é o nome da classe concreta (`new.target.name`) e o
+* protótipo é ajustado explicitamente para que `instanceof` funcione mesmo em
+* subclasses e em alvos de compilação antigos.
+*
+* @example
+* ```ts
+* try {
+*   defineErrorCatalog({ userNotFound: "Usuário não encontrado" });
+* } catch (error) {
+*   if (error instanceof InvalidErrorCode) {
+*     error.code;    // "userNotFound"
+*     error.message; // 'Código de erro inválido "userNotFound". Os códigos de erro devem usar UPPER_SNAKE_CASE.'
+*   }
+* }
+* ```
+*/
+var InvalidErrorCode = class extends TypeError {
+	/** Código de erro inválido que provocou a exceção. */
+	code;
+	/**
+	* Cria o erro de código inválido.
+	*
+	* @param code - Código de erro que não está em UPPER_SNAKE_CASE.
+	* @param options - Opções padrão de `Error` como `cause`.
+	*/
+	constructor(code, options) {
+		super(invalidCodeMessage(code), options);
+		this.name = new.target.name;
+		this.code = code;
+		Object.setPrototypeOf(this, new.target.prototype);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, new.target);
+	}
+};
+//#endregion
+//#region src/errors/either-unwrap-error.ts
+/**
+* Erro lançado quando `unwrap()` é chamado em um `Err` ou `unwrapErr()` é
+* chamado em um `Ok`, ou seja, quando se tenta extrair de um {@link Either}
+* o valor da variante que ele não possui.
+*
+* O valor contido na variante realmente presente é anexado como `cause`
+* (o valor de erro em `unwrap()` num `Err`; o valor de sucesso em
+* `unwrapErr()` num `Ok`). Esse valor pode ser de qualquer tipo, não
+* necessariamente um `Error`.
+*
+* O `name` do erro é o nome da classe concreta (`new.target.name`) e o
+* protótipo é ajustado explicitamente para que `instanceof` funcione mesmo em
+* subclasses e em alvos de compilação antigos.
+*
+* @example
+* ```ts
+* try {
+*   err<number, string>("falhou").unwrap();
+* } catch (error) {
+*   if (error instanceof EitherUnwrapError) {
+*     error.message; // "Chamado unwrap() em Err."
+*     error.cause;   // "falhou"
+*   }
+* }
+* ```
+*/
+var EitherUnwrapError = class extends Error {
+	/**
+	* Cria o erro de extração inválida de um `Either`.
+	*
+	* @param message - Mensagem do erro. Por padrão, uma mensagem genérica
+	* ("Chamado unwrap() ou unwrapErr() em resultado incompatível.").
+	* @param options - Opções padrão de `Error` como `cause` que normalmente
+	* carrega o valor contido no `Either`.
+	*/
+	constructor(message = "Chamado unwrap() ou unwrapErr() em resultado incompatível.", options) {
+		super(message, options);
+		this.name = new.target.name;
+		Object.setPrototypeOf(this, new.target.prototype);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, new.target);
+	}
+};
+//#endregion
+export { isUpperSnakeCase as a, invalidCodeMessage as i, InvalidErrorCode as n, UPPER_SNAKE_CASE as r, EitherUnwrapError as t };
+
+//# sourceMappingURL=errors-DrDL51y9.mjs.map

package/dist/errors-DrDL51y9.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-DrDL51y9.mjs","names":[],"sources":["../src/upper-snake-case.ts","../src/errors/invalid-error-code.ts","../src/errors/either-unwrap-error.ts"],"sourcesContent":["import type {\n\tInvalidCodeMessage,\n\tIsUpperSnakeCase,\n} from \"./types/validate-error-definitions.js\";\n\n/**\n * Expressão regular que valida códigos em UPPER_SNAKE_CASE em tempo de\n * execução.\n *\n * Regras (espelham o tipo {@link IsUpperSnakeCase}):\n * - deve começar com uma letra maiúscula (`A-Z`);\n * - pode conter letras maiúsculas, dígitos e `_`;\n * - `_` só pode aparecer entre caracteres alfanuméricos, ou seja, não pode\n *   estar no início nem no fim e não pode ser repetido em sequência.\n */\nexport const UPPER_SNAKE_CASE = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;\n\n/**\n * Verifica em tempo de execução, se uma string está em UPPER_SNAKE_CASE.\n *\n * É o equivalente em runtime do tipo {@link IsUpperSnakeCase}, usando a\n * expressão regular {@link UPPER_SNAKE_CASE}.\n *\n * @param value - String a ser verificada.\n * @returns `true` se `value` estiver em UPPER_SNAKE_CASE; caso contrário,\n * `false`.\n *\n * @example\n * ```ts\n * isUpperSnakeCase(\"USER_NOT_FOUND\"); // true\n * isUpperSnakeCase(\"ERROR_404\");      // true\n * isUpperSnakeCase(\"userNotFound\");   // false\n * isUpperSnakeCase(\"_USER\");          // false\n * isUpperSnakeCase(\"USER__NOT\");      // false\n * isUpperSnakeCase(\"1ERROR\");         // false\n * ```\n */\nexport function isUpperSnakeCase(value: string) {\n\treturn UPPER_SNAKE_CASE.test(value);\n}\n\n/**\n * Monta a mensagem de erro exibida quando um código não está em\n * UPPER_SNAKE_CASE.\n *\n * O retorno é tipado como {@link InvalidCodeMessage}, de modo que o texto em\n * runtime corresponde exatamente ao tipo literal usado na validação em tempo\n * de compilação.\n *\n * @template Code - Tipo literal do código inválido.\n * @param code - Código de erro inválido a ser incluído na mensagem.\n * @returns Mensagem descrevendo o código inválido e o formato esperado.\n *\n * @example\n * ```ts\n * invalidCodeMessage(\"userNotFound\");\n * // 'Código de erro inválido \"userNotFound\". Os códigos de erro devem usar UPPER_SNAKE_CASE.'\n * ```\n */\nexport function invalidCodeMessage<Code extends string>(\n\tcode: Code,\n): InvalidCodeMessage<Code> {\n\treturn `Código de erro inválido \"${code}\". Os códigos de erro devem usar UPPER_SNAKE_CASE.`;\n}\n","import { invalidCodeMessage } from \"#/upper-snake-case.js\";\r\n\r\n/**\r\n * Erro lançado quando um código de erro não está em UPPER_SNAKE_CASE.\r\n *\r\n * Estende `TypeError` pois indica um valor de tipo ou formato inadequado.\r\n * É lançado em tempo de execução por `defineErrorCatalog` complementando a\r\n * validação feita em tempo de compilação por `ValidateErrorDefinitions`.\r\n *\r\n * A mensagem é gerada por {@link invalidCodeMessage} e o código inválido fica\r\n * disponível na propriedade `code`.\r\n *\r\n * O `name` do erro é o nome da classe concreta (`new.target.name`) e o\r\n * protótipo é ajustado explicitamente para que `instanceof` funcione mesmo em\r\n * subclasses e em alvos de compilação antigos.\r\n *\r\n * @example\r\n * ```ts\r\n * try {\r\n *   defineErrorCatalog({ userNotFound: \"Usuário não encontrado\" });\r\n * } catch (error) {\r\n *   if (error instanceof InvalidErrorCode) {\r\n *     error.code;    // \"userNotFound\"\r\n *     error.message; // 'Código de erro inválido \"userNotFound\". Os códigos de erro devem usar UPPER_SNAKE_CASE.'\r\n *   }\r\n * }\r\n * ```\r\n */\r\nexport class InvalidErrorCode extends TypeError {\r\n  /** Código de erro inválido que provocou a exceção. */\r\n  public readonly code: string;\r\n\r\n  /**\r\n   * Cria o erro de código inválido.\r\n   *\r\n   * @param code - Código de erro que não está em UPPER_SNAKE_CASE.\r\n   * @param options - Opções padrão de `Error` como `cause`.\r\n   */\r\n  public constructor(code: string, options?: ErrorOptions) {\r\n    super(invalidCodeMessage(code), options);\r\n\r\n    this.name = new.target.name;\r\n    this.code = code;\r\n\r\n    Object.setPrototypeOf(this, new.target.prototype);\r\n\r\n    if (Error.captureStackTrace) {\r\n      Error.captureStackTrace(this, new.target);\r\n    }\r\n  }\r\n}\r\n","import { Either } from \"#/either.js\";\r\n\r\n/**\r\n * Erro lançado quando `unwrap()` é chamado em um `Err` ou `unwrapErr()` é\r\n * chamado em um `Ok`, ou seja, quando se tenta extrair de um {@link Either}\r\n * o valor da variante que ele não possui.\r\n *\r\n * O valor contido na variante realmente presente é anexado como `cause`\r\n * (o valor de erro em `unwrap()` num `Err`; o valor de sucesso em\r\n * `unwrapErr()` num `Ok`). Esse valor pode ser de qualquer tipo, não\r\n * necessariamente um `Error`.\r\n *\r\n * O `name` do erro é o nome da classe concreta (`new.target.name`) e o\r\n * protótipo é ajustado explicitamente para que `instanceof` funcione mesmo em\r\n * subclasses e em alvos de compilação antigos.\r\n *\r\n * @example\r\n * ```ts\r\n * try {\r\n *   err<number, string>(\"falhou\").unwrap();\r\n * } catch (error) {\r\n *   if (error instanceof EitherUnwrapError) {\r\n *     error.message; // \"Chamado unwrap() em Err.\"\r\n *     error.cause;   // \"falhou\"\r\n *   }\r\n * }\r\n * ```\r\n */\r\nexport class EitherUnwrapError extends Error {\r\n  /**\r\n   * Cria o erro de extração inválida de um `Either`.\r\n   *\r\n   * @param message - Mensagem do erro. Por padrão, uma mensagem genérica\r\n   * (\"Chamado unwrap() ou unwrapErr() em resultado incompatível.\").\r\n   * @param options - Opções padrão de `Error` como `cause` que normalmente\r\n   * carrega o valor contido no `Either`.\r\n   */\r\n  public constructor(\r\n    message = \"Chamado unwrap() ou unwrapErr() em resultado incompatível.\",\r\n    options?: ErrorOptions,\r\n  ) {\r\n    super(message, options);\r\n\r\n    this.name = new.target.name;\r\n\r\n    Object.setPrototypeOf(this, new.target.prototype);\r\n\r\n    if (Error.captureStackTrace) {\r\n      Error.captureStackTrace(this, new.target);\r\n    }\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;;;;AAeA,MAAa,mBAAmB;;;;;;;;;;;;;;;;;;;;;AAsBhC,SAAgB,iBAAiB,OAAe;CAC/C,OAAO,iBAAiB,KAAK,KAAK;AACnC;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,mBACf,MAC2B;CAC3B,OAAO,4BAA4B,KAAK;AACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACnCA,IAAa,mBAAb,cAAsC,UAAU;;CAE9C;;;;;;;CAQA,YAAmB,MAAc,SAAwB;EACvD,MAAM,mBAAmB,IAAI,GAAG,OAAO;EAEvC,KAAK,OAAO,WAAW;EACvB,KAAK,OAAO;EAEZ,OAAO,eAAe,MAAM,WAAW,SAAS;EAEhD,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,UAAU;CAE5C;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACtBA,IAAa,oBAAb,cAAuC,MAAM;;;;;;;;;CAS3C,YACE,UAAU,8DACV,SACA;EACA,MAAM,SAAS,OAAO;EAEtB,KAAK,OAAO,WAAW;EAEvB,OAAO,eAAe,MAAM,WAAW,SAAS;EAEhD,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,UAAU;CAE5C;AACF"}

package/dist/errors-TgPe2YUV.cjs

@@ -0,0 +1,178 @@
+//#region src/upper-snake-case.ts
+/**
+* Expressão regular que valida códigos em UPPER_SNAKE_CASE em tempo de
+* execução.
+*
+* Regras (espelham o tipo {@link IsUpperSnakeCase}):
+* - deve começar com uma letra maiúscula (`A-Z`);
+* - pode conter letras maiúsculas, dígitos e `_`;
+* - `_` só pode aparecer entre caracteres alfanuméricos, ou seja, não pode
+*   estar no início nem no fim e não pode ser repetido em sequência.
+*/
+const UPPER_SNAKE_CASE = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
+/**
+* Verifica em tempo de execução, se uma string está em UPPER_SNAKE_CASE.
+*
+* É o equivalente em runtime do tipo {@link IsUpperSnakeCase}, usando a
+* expressão regular {@link UPPER_SNAKE_CASE}.
+*
+* @param value - String a ser verificada.
+* @returns `true` se `value` estiver em UPPER_SNAKE_CASE; caso contrário,
+* `false`.
+*
+* @example
+* ```ts
+* isUpperSnakeCase("USER_NOT_FOUND"); // true
+* isUpperSnakeCase("ERROR_404");      // true
+* isUpperSnakeCase("userNotFound");   // false
+* isUpperSnakeCase("_USER");          // false
+* isUpperSnakeCase("USER__NOT");      // false
+* isUpperSnakeCase("1ERROR");         // false
+* ```
+*/
+function isUpperSnakeCase(value) {
+	return UPPER_SNAKE_CASE.test(value);
+}
+/**
+* Monta a mensagem de erro exibida quando um código não está em
+* UPPER_SNAKE_CASE.
+*
+* O retorno é tipado como {@link InvalidCodeMessage}, de modo que o texto em
+* runtime corresponde exatamente ao tipo literal usado na validação em tempo
+* de compilação.
+*
+* @template Code - Tipo literal do código inválido.
+* @param code - Código de erro inválido a ser incluído na mensagem.
+* @returns Mensagem descrevendo o código inválido e o formato esperado.
+*
+* @example
+* ```ts
+* invalidCodeMessage("userNotFound");
+* // 'Código de erro inválido "userNotFound". Os códigos de erro devem usar UPPER_SNAKE_CASE.'
+* ```
+*/
+function invalidCodeMessage(code) {
+	return `Código de erro inválido "${code}". Os códigos de erro devem usar UPPER_SNAKE_CASE.`;
+}
+//#endregion
+//#region src/errors/invalid-error-code.ts
+/**
+* Erro lançado quando um código de erro não está em UPPER_SNAKE_CASE.
+*
+* Estende `TypeError` pois indica um valor de tipo ou formato inadequado.
+* É lançado em tempo de execução por `defineErrorCatalog` complementando a
+* validação feita em tempo de compilação por `ValidateErrorDefinitions`.
+*
+* A mensagem é gerada por {@link invalidCodeMessage} e o código inválido fica
+* disponível na propriedade `code`.
+*
+* O `name` do erro é o nome da classe concreta (`new.target.name`) e o
+* protótipo é ajustado explicitamente para que `instanceof` funcione mesmo em
+* subclasses e em alvos de compilação antigos.
+*
+* @example
+* ```ts
+* try {
+*   defineErrorCatalog({ userNotFound: "Usuário não encontrado" });
+* } catch (error) {
+*   if (error instanceof InvalidErrorCode) {
+*     error.code;    // "userNotFound"
+*     error.message; // 'Código de erro inválido "userNotFound". Os códigos de erro devem usar UPPER_SNAKE_CASE.'
+*   }
+* }
+* ```
+*/
+var InvalidErrorCode = class extends TypeError {
+	/** Código de erro inválido que provocou a exceção. */
+	code;
+	/**
+	* Cria o erro de código inválido.
+	*
+	* @param code - Código de erro que não está em UPPER_SNAKE_CASE.
+	* @param options - Opções padrão de `Error` como `cause`.
+	*/
+	constructor(code, options) {
+		super(invalidCodeMessage(code), options);
+		this.name = new.target.name;
+		this.code = code;
+		Object.setPrototypeOf(this, new.target.prototype);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, new.target);
+	}
+};
+//#endregion
+//#region src/errors/either-unwrap-error.ts
+/**
+* Erro lançado quando `unwrap()` é chamado em um `Err` ou `unwrapErr()` é
+* chamado em um `Ok`, ou seja, quando se tenta extrair de um {@link Either}
+* o valor da variante que ele não possui.
+*
+* O valor contido na variante realmente presente é anexado como `cause`
+* (o valor de erro em `unwrap()` num `Err`; o valor de sucesso em
+* `unwrapErr()` num `Ok`). Esse valor pode ser de qualquer tipo, não
+* necessariamente um `Error`.
+*
+* O `name` do erro é o nome da classe concreta (`new.target.name`) e o
+* protótipo é ajustado explicitamente para que `instanceof` funcione mesmo em
+* subclasses e em alvos de compilação antigos.
+*
+* @example
+* ```ts
+* try {
+*   err<number, string>("falhou").unwrap();
+* } catch (error) {
+*   if (error instanceof EitherUnwrapError) {
+*     error.message; // "Chamado unwrap() em Err."
+*     error.cause;   // "falhou"
+*   }
+* }
+* ```
+*/
+var EitherUnwrapError = class extends Error {
+	/**
+	* Cria o erro de extração inválida de um `Either`.
+	*
+	* @param message - Mensagem do erro. Por padrão, uma mensagem genérica
+	* ("Chamado unwrap() ou unwrapErr() em resultado incompatível.").
+	* @param options - Opções padrão de `Error` como `cause` que normalmente
+	* carrega o valor contido no `Either`.
+	*/
+	constructor(message = "Chamado unwrap() ou unwrapErr() em resultado incompatível.", options) {
+		super(message, options);
+		this.name = new.target.name;
+		Object.setPrototypeOf(this, new.target.prototype);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, new.target);
+	}
+};
+//#endregion
+Object.defineProperty(exports, "EitherUnwrapError", {
+	enumerable: true,
+	get: function() {
+		return EitherUnwrapError;
+	}
+});
+Object.defineProperty(exports, "InvalidErrorCode", {
+	enumerable: true,
+	get: function() {
+		return InvalidErrorCode;
+	}
+});
+Object.defineProperty(exports, "UPPER_SNAKE_CASE", {
+	enumerable: true,
+	get: function() {
+		return UPPER_SNAKE_CASE;
+	}
+});
+Object.defineProperty(exports, "invalidCodeMessage", {
+	enumerable: true,
+	get: function() {
+		return invalidCodeMessage;
+	}
+});
+Object.defineProperty(exports, "isUpperSnakeCase", {
+	enumerable: true,
+	get: function() {
+		return isUpperSnakeCase;
+	}
+});
+
+//# sourceMappingURL=errors-TgPe2YUV.cjs.map

package/dist/errors-TgPe2YUV.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-TgPe2YUV.cjs","names":[],"sources":["../src/upper-snake-case.ts","../src/errors/invalid-error-code.ts","../src/errors/either-unwrap-error.ts"],"sourcesContent":["import type {\n\tInvalidCodeMessage,\n\tIsUpperSnakeCase,\n} from \"./types/validate-error-definitions.js\";\n\n/**\n * Expressão regular que valida códigos em UPPER_SNAKE_CASE em tempo de\n * execução.\n *\n * Regras (espelham o tipo {@link IsUpperSnakeCase}):\n * - deve começar com uma letra maiúscula (`A-Z`);\n * - pode conter letras maiúsculas, dígitos e `_`;\n * - `_` só pode aparecer entre caracteres alfanuméricos, ou seja, não pode\n *   estar no início nem no fim e não pode ser repetido em sequência.\n */\nexport const UPPER_SNAKE_CASE = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;\n\n/**\n * Verifica em tempo de execução, se uma string está em UPPER_SNAKE_CASE.\n *\n * É o equivalente em runtime do tipo {@link IsUpperSnakeCase}, usando a\n * expressão regular {@link UPPER_SNAKE_CASE}.\n *\n * @param value - String a ser verificada.\n * @returns `true` se `value` estiver em UPPER_SNAKE_CASE; caso contrário,\n * `false`.\n *\n * @example\n * ```ts\n * isUpperSnakeCase(\"USER_NOT_FOUND\"); // true\n * isUpperSnakeCase(\"ERROR_404\");      // true\n * isUpperSnakeCase(\"userNotFound\");   // false\n * isUpperSnakeCase(\"_USER\");          // false\n * isUpperSnakeCase(\"USER__NOT\");      // false\n * isUpperSnakeCase(\"1ERROR\");         // false\n * ```\n */\nexport function isUpperSnakeCase(value: string) {\n\treturn UPPER_SNAKE_CASE.test(value);\n}\n\n/**\n * Monta a mensagem de erro exibida quando um código não está em\n * UPPER_SNAKE_CASE.\n *\n * O retorno é tipado como {@link InvalidCodeMessage}, de modo que o texto em\n * runtime corresponde exatamente ao tipo literal usado na validação em tempo\n * de compilação.\n *\n * @template Code - Tipo literal do código inválido.\n * @param code - Código de erro inválido a ser incluído na mensagem.\n * @returns Mensagem descrevendo o código inválido e o formato esperado.\n *\n * @example\n * ```ts\n * invalidCodeMessage(\"userNotFound\");\n * // 'Código de erro inválido \"userNotFound\". Os códigos de erro devem usar UPPER_SNAKE_CASE.'\n * ```\n */\nexport function invalidCodeMessage<Code extends string>(\n\tcode: Code,\n): InvalidCodeMessage<Code> {\n\treturn `Código de erro inválido \"${code}\". Os códigos de erro devem usar UPPER_SNAKE_CASE.`;\n}\n","import { invalidCodeMessage } from \"#/upper-snake-case.js\";\r\n\r\n/**\r\n * Erro lançado quando um código de erro não está em UPPER_SNAKE_CASE.\r\n *\r\n * Estende `TypeError` pois indica um valor de tipo ou formato inadequado.\r\n * É lançado em tempo de execução por `defineErrorCatalog` complementando a\r\n * validação feita em tempo de compilação por `ValidateErrorDefinitions`.\r\n *\r\n * A mensagem é gerada por {@link invalidCodeMessage} e o código inválido fica\r\n * disponível na propriedade `code`.\r\n *\r\n * O `name` do erro é o nome da classe concreta (`new.target.name`) e o\r\n * protótipo é ajustado explicitamente para que `instanceof` funcione mesmo em\r\n * subclasses e em alvos de compilação antigos.\r\n *\r\n * @example\r\n * ```ts\r\n * try {\r\n *   defineErrorCatalog({ userNotFound: \"Usuário não encontrado\" });\r\n * } catch (error) {\r\n *   if (error instanceof InvalidErrorCode) {\r\n *     error.code;    // \"userNotFound\"\r\n *     error.message; // 'Código de erro inválido \"userNotFound\". Os códigos de erro devem usar UPPER_SNAKE_CASE.'\r\n *   }\r\n * }\r\n * ```\r\n */\r\nexport class InvalidErrorCode extends TypeError {\r\n  /** Código de erro inválido que provocou a exceção. */\r\n  public readonly code: string;\r\n\r\n  /**\r\n   * Cria o erro de código inválido.\r\n   *\r\n   * @param code - Código de erro que não está em UPPER_SNAKE_CASE.\r\n   * @param options - Opções padrão de `Error` como `cause`.\r\n   */\r\n  public constructor(code: string, options?: ErrorOptions) {\r\n    super(invalidCodeMessage(code), options);\r\n\r\n    this.name = new.target.name;\r\n    this.code = code;\r\n\r\n    Object.setPrototypeOf(this, new.target.prototype);\r\n\r\n    if (Error.captureStackTrace) {\r\n      Error.captureStackTrace(this, new.target);\r\n    }\r\n  }\r\n}\r\n","import { Either } from \"#/either.js\";\r\n\r\n/**\r\n * Erro lançado quando `unwrap()` é chamado em um `Err` ou `unwrapErr()` é\r\n * chamado em um `Ok`, ou seja, quando se tenta extrair de um {@link Either}\r\n * o valor da variante que ele não possui.\r\n *\r\n * O valor contido na variante realmente presente é anexado como `cause`\r\n * (o valor de erro em `unwrap()` num `Err`; o valor de sucesso em\r\n * `unwrapErr()` num `Ok`). Esse valor pode ser de qualquer tipo, não\r\n * necessariamente um `Error`.\r\n *\r\n * O `name` do erro é o nome da classe concreta (`new.target.name`) e o\r\n * protótipo é ajustado explicitamente para que `instanceof` funcione mesmo em\r\n * subclasses e em alvos de compilação antigos.\r\n *\r\n * @example\r\n * ```ts\r\n * try {\r\n *   err<number, string>(\"falhou\").unwrap();\r\n * } catch (error) {\r\n *   if (error instanceof EitherUnwrapError) {\r\n *     error.message; // \"Chamado unwrap() em Err.\"\r\n *     error.cause;   // \"falhou\"\r\n *   }\r\n * }\r\n * ```\r\n */\r\nexport class EitherUnwrapError extends Error {\r\n  /**\r\n   * Cria o erro de extração inválida de um `Either`.\r\n   *\r\n   * @param message - Mensagem do erro. Por padrão, uma mensagem genérica\r\n   * (\"Chamado unwrap() ou unwrapErr() em resultado incompatível.\").\r\n   * @param options - Opções padrão de `Error` como `cause` que normalmente\r\n   * carrega o valor contido no `Either`.\r\n   */\r\n  public constructor(\r\n    message = \"Chamado unwrap() ou unwrapErr() em resultado incompatível.\",\r\n    options?: ErrorOptions,\r\n  ) {\r\n    super(message, options);\r\n\r\n    this.name = new.target.name;\r\n\r\n    Object.setPrototypeOf(this, new.target.prototype);\r\n\r\n    if (Error.captureStackTrace) {\r\n      Error.captureStackTrace(this, new.target);\r\n    }\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;;;;AAeA,MAAa,mBAAmB;;;;;;;;;;;;;;;;;;;;;AAsBhC,SAAgB,iBAAiB,OAAe;CAC/C,OAAO,iBAAiB,KAAK,KAAK;AACnC;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,mBACf,MAC2B;CAC3B,OAAO,4BAA4B,KAAK;AACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACnCA,IAAa,mBAAb,cAAsC,UAAU;;CAE9C;;;;;;;CAQA,YAAmB,MAAc,SAAwB;EACvD,MAAM,mBAAmB,IAAI,GAAG,OAAO;EAEvC,KAAK,OAAO,WAAW;EACvB,KAAK,OAAO;EAEZ,OAAO,eAAe,MAAM,WAAW,SAAS;EAEhD,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,UAAU;CAE5C;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACtBA,IAAa,oBAAb,cAAuC,MAAM;;;;;;;;;CAS3C,YACE,UAAU,8DACV,SACA;EACA,MAAM,SAAS,OAAO;EAEtB,KAAK,OAAO,WAAW;EAEvB,OAAO,eAAe,MAAM,WAAW,SAAS;EAEhD,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,UAAU;CAE5C;AACF"}