@visulima/error-handler 2.0.0-alpha.11 → 2.0.0-alpha.12

package/CHANGELOG.md

@@ -1,3 +1,29 @@
+## @visulima/error-handler [2.0.0-alpha.12](https://github.com/visulima/visulima/compare/@visulima/error-handler@2.0.0-alpha.11...@visulima/error-handler@2.0.0-alpha.12) (2026-04-22)
+
+### Bug Fixes
+
+* **error-debugging:** resolve eslint and formatting issues ([7d0ada8](https://github.com/visulima/visulima/commit/7d0ada8787bf624df5a7d504448a4d1b69165aba))
+* **error-debugging:** resolve eslint and type-safety issues ([886dbff](https://github.com/visulima/visulima/commit/886dbffe3f744c9493fcc54e781de3fd21eebf78))
+* **error-handler:** remove unused [@ts-expect-error](https://github.com/ts-expect-error) on end() overload ([a8eb6a6](https://github.com/visulima/visulima/commit/a8eb6a6ab8d42c1a6881dda5c605a4d20dde069f))
+* **error-handler:** resolve eslint and formatting issues ([324f5d8](https://github.com/visulima/visulima/commit/324f5d89f1bcceac4fbe44c6002040aa63be1ec9))
+* Remove JSR configuration generation script and generated jsr.json files ([#616](https://github.com/visulima/visulima/issues/616)) ([533744b](https://github.com/visulima/visulima/commit/533744b103b74896941db5b727173e617a27a63b))
+
+### Miscellaneous Chores
+
+* bump engines.node to ^22.14.0 || >=24.10.0 ([c3d0931](https://github.com/visulima/visulima/commit/c3d0931d1504e4f21ebf50ea680cfa7ce4ba15ce))
+* **error-handler:** apply formatter and lint fixes ([9ab7d48](https://github.com/visulima/visulima/commit/9ab7d48758f89b434e8c463c45f94eedc4619ab9))
+* **error-handler:** enforce curly braces and apply lint fixes ([ced1569](https://github.com/visulima/visulima/commit/ced1569c34fde28975eda76e5e84db6d87059865))
+* fixed jsr.json ([5d85e51](https://github.com/visulima/visulima/commit/5d85e5179de38e284ec433b14d77c71a1619c8d6))
+
+### Continuous Integration
+
+* disable isolatedDeclarationTransformer ([d5845d8](https://github.com/visulima/visulima/commit/d5845d888012fbe20a020cb2c02ec57269356e56))
+
+
+### Dependencies
+
+* **@visulima/boxen:** upgraded to 3.0.0-alpha.10
+
 ## @visulima/error-handler [2.0.0-alpha.11](https://github.com/visulima/visulima/compare/@visulima/error-handler@2.0.0-alpha.10...@visulima/error-handler@2.0.0-alpha.11) (2026-04-08)
 
 ### Bug Fixes

package/dist/error-handler/html-error-handler.d.ts

@@ -1,13 +1,14 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ErrorHandler } from "./types.d.d.ts";
-export type HtmlErrorHandlerOptions = {
-    cspNonce?: string;
-    errorPage?: string | ((parameters: {
-        error: Error;
-        reasonPhrase: string;
-        request: IncomingMessage;
-        response: ServerResponse;
-        statusCode: number;
-    }) => string | Promise<string>);
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { a as ErrorHandler } from "../packem_shared/types.d-C763gSYq.js";
+type HtmlErrorHandlerOptions = {
+  cspNonce?: string;
+  errorPage?: string | ((parameters: {
+    error: Error;
+    reasonPhrase: string;
+    request: IncomingMessage;
+    response: ServerResponse;
+    statusCode: number;
+  }) => string | Promise<string>);
 };
-export declare const htmlErrorHandler: (options?: HtmlErrorHandlerOptions) => ErrorHandler;
+declare const htmlErrorHandler: (options?: HtmlErrorHandlerOptions) => ErrorHandler;
+export { HtmlErrorHandlerOptions, htmlErrorHandler };

package/dist/error-handler/json-error-handler.d.ts

@@ -1,14 +1,15 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ErrorHandler } from "./types.d.d.ts";
-export type JsonErrorBody = Record<string, unknown> | unknown[];
-export type JsonErrorFormatter = (parameters: {
-    error: Error;
-    reasonPhrase: string;
-    request: IncomingMessage;
-    response: ServerResponse;
-    statusCode: number;
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { a as ErrorHandler } from "../packem_shared/types.d-C763gSYq.js";
+type JsonErrorBody = Record<string, unknown> | unknown[];
+type JsonErrorFormatter = (parameters: {
+  error: Error;
+  reasonPhrase: string;
+  request: IncomingMessage;
+  response: ServerResponse;
+  statusCode: number;
 }) => JsonErrorBody | Promise<JsonErrorBody>;
-export type JsonErrorHandlerOptions = {
-    formatter?: JsonErrorFormatter;
+type JsonErrorHandlerOptions = {
+  formatter?: JsonErrorFormatter;
 };
-export declare const jsonErrorHandler: (options?: JsonErrorHandlerOptions) => ErrorHandler;
+declare const jsonErrorHandler: (options?: JsonErrorHandlerOptions) => ErrorHandler;
+export { JsonErrorBody, JsonErrorFormatter, JsonErrorHandlerOptions, jsonErrorHandler };

package/dist/error-handler/jsonapi-error-handler.d.ts

@@ -1,3 +1,4 @@
-import type { ErrorHandler } from "./types.d.d.ts";
+import { a as ErrorHandler } from "../packem_shared/types.d-C763gSYq.js";
+import 'node:http';
 declare const jsonapiErrorHandler: ErrorHandler;
-export default jsonapiErrorHandler;
+export { jsonapiErrorHandler as default };

package/dist/error-handler/jsonp-error-handler.d.ts

@@ -1,16 +1,16 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ErrorHandler } from "./types.d.d.ts";
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { a as ErrorHandler } from "../packem_shared/types.d-C763gSYq.js";
 declare const jsonpErrorHandler: (options?: JsonpErrorHandlerOptions) => ErrorHandler;
-export type JsonpErrorBody = Record<string, unknown> | unknown[];
-export type JsonpErrorFormatter = (parameters: {
-    error: Error;
-    reasonPhrase: string;
-    request: IncomingMessage;
-    response: ServerResponse;
-    statusCode: number;
+type JsonpErrorBody = Record<string, unknown> | unknown[];
+type JsonpErrorFormatter = (parameters: {
+  error: Error;
+  reasonPhrase: string;
+  request: IncomingMessage;
+  response: ServerResponse;
+  statusCode: number;
 }) => JsonpErrorBody | Promise<JsonpErrorBody>;
-export type JsonpErrorHandlerOptions = {
-    callbackParamName?: string;
-    formatter?: JsonpErrorFormatter;
+type JsonpErrorHandlerOptions = {
+  callbackParamName?: string;
+  formatter?: JsonpErrorFormatter;
 };
-export { jsonpErrorHandler };
+export { JsonpErrorBody, JsonpErrorFormatter, JsonpErrorHandlerOptions, jsonpErrorHandler };

package/dist/error-handler/problem-error-handler.d.ts

@@ -1,7 +1,4 @@
-import type { ErrorHandler } from "./types.d.d.ts";
-/**
- * Normalizes errors according to the API Problem spec (RFC 7807).
- * @see https://tools.ietf.org/html/rfc7807
- */
+import { a as ErrorHandler } from "../packem_shared/types.d-C763gSYq.js";
+import 'node:http';
 declare const problemErrorHandler: ErrorHandler;
-export default problemErrorHandler;
+export { problemErrorHandler as default };

package/dist/error-handler/text-error-handler.d.ts

@@ -1,13 +1,14 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ErrorHandler } from "./types.d.d.ts";
-export type TextErrorFormatter = (parameters: {
-    error: Error;
-    reasonPhrase: string;
-    request: IncomingMessage;
-    response: ServerResponse;
-    statusCode: number;
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { a as ErrorHandler } from "../packem_shared/types.d-C763gSYq.js";
+type TextErrorFormatter = (parameters: {
+  error: Error;
+  reasonPhrase: string;
+  request: IncomingMessage;
+  response: ServerResponse;
+  statusCode: number;
 }) => string | Promise<string>;
-export type TextErrorHandlerOptions = {
-    formatter?: TextErrorFormatter;
+type TextErrorHandlerOptions = {
+  formatter?: TextErrorFormatter;
 };
-export declare const textErrorHandler: (options?: TextErrorHandlerOptions) => ErrorHandler;
+declare const textErrorHandler: (options?: TextErrorHandlerOptions) => ErrorHandler;
+export { TextErrorFormatter, TextErrorHandlerOptions, textErrorHandler };

package/dist/error-handler/xml-error-handler.d.ts

@@ -1,26 +1,27 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ErrorHandler } from "./types.d.d.ts";
-export type XmlErrorBody = Record<string, unknown> | unknown[];
-export type XmlErrorFormatter = (parameters: {
-    error: Error;
-    reasonPhrase: string;
-    request: IncomingMessage;
-    response: ServerResponse;
-    statusCode: number;
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { a as ErrorHandler } from "../packem_shared/types.d-C763gSYq.js";
+type XmlErrorBody = Record<string, unknown> | unknown[];
+type XmlErrorFormatter = (parameters: {
+  error: Error;
+  reasonPhrase: string;
+  request: IncomingMessage;
+  response: ServerResponse;
+  statusCode: number;
 }) => XmlErrorBody | Promise<XmlErrorBody>;
-export type ToXmlOptions = {
-    attributeExplicitTrue?: boolean;
-    attributeFilter?: (key: string, value: unknown) => boolean;
-    attributeReplacements?: Record<string, string>;
-    contentMap?: (content: string) => string;
-    contentReplacements?: Record<string, string>;
-    header?: string | boolean;
-    indent?: string;
-    selfCloseTags?: boolean;
+type ToXmlOptions = {
+  attributeExplicitTrue?: boolean;
+  attributeFilter?: (key: string, value: unknown) => boolean;
+  attributeReplacements?: Record<string, string>;
+  contentMap?: (content: string) => string;
+  contentReplacements?: Record<string, string>;
+  header?: string | boolean;
+  indent?: string;
+  selfCloseTags?: boolean;
 };
-export type XmlErrorHandlerOptions = {
-    formatter?: XmlErrorFormatter;
-    toXml?: ToXmlOptions;
-    xmlHeader?: boolean;
+type XmlErrorHandlerOptions = {
+  formatter?: XmlErrorFormatter;
+  toXml?: ToXmlOptions;
+  xmlHeader?: boolean;
 };
-export declare const xmlErrorHandler: (options?: XmlErrorHandlerOptions) => ErrorHandler;
+declare const xmlErrorHandler: (options?: XmlErrorHandlerOptions) => ErrorHandler;
+export { ToXmlOptions, XmlErrorBody, XmlErrorFormatter, XmlErrorHandlerOptions, xmlErrorHandler };

package/dist/handler/cli-handler.d.ts

@@ -1,4 +1,27 @@
-import type { BaseCliOptions } from "../../../../../shared/utils/cli-error-builder.d.ts";
-export type { BaseCliOptions, CliHandlerOptions } from "../../../../../shared/utils/cli-error-builder.d.ts";
-export declare const ansiHandler: (error: Error, options?: BaseCliOptions) => Promise<string>;
-export { terminalOutput as cliHandler } from "../../../../../shared/utils/cli-error-builder.d.ts";
+import { RenderErrorOptions } from '@visulima/error/error';
+import { SolutionFinder } from '@visulima/error/solution';
+type CliLogger = {
+  error: (...arguments_: unknown[]) => void;
+  log: (...arguments_: unknown[]) => void;
+};
+type ColorizeMethod = (value: string) => string;
+type BaseCliOptions = {
+  solutionTitle?: string;
+  solutionFinders?: SolutionFinder[];
+  debug?: boolean;
+} & Partial<Omit<RenderErrorOptions, "color">> & {
+  color?: {
+    codeFrame?: RenderErrorOptions["color"];
+    boxen?: {
+      headerTextColor?: ColorizeMethod;
+      textColor?: ColorizeMethod;
+      borderColor?: ColorizeMethod;
+    };
+  };
+};
+type CliHandlerOptions = BaseCliOptions & {
+  logger?: CliLogger;
+};
+declare const terminalOutput: (error: Error, options?: CliHandlerOptions) => Promise<void>;
+declare const ansiHandler: (error: Error, options?: BaseCliOptions) => Promise<string>;
+export { type BaseCliOptions, type CliHandlerOptions, ansiHandler, terminalOutput as cliHandler };

package/dist/handler/http/fetch-handler.d.ts

@@ -1,8 +1,9 @@
-import type { HtmlErrorHandlerOptions } from "../../error-handler/html-error-handler.d.ts";
-import type { FetchErrorHandlers } from "../../error-handler/types.d.d.ts";
+import { HtmlErrorHandlerOptions } from "../../error-handler/html-error-handler.js";
+import { F as FetchErrorHandlers } from "../../packem_shared/types.d-C763gSYq.js";
+import 'node:http';
 declare const fetchHandler: (error: Error, options?: HtmlErrorHandlerOptions & {
-    extraHandlers?: FetchErrorHandlers;
-    onError?: (error: Error, request: Request) => void | Promise<void>;
-    showTrace?: boolean;
-}) => (request: Request) => Promise<Response>;
-export default fetchHandler;
+  extraHandlers?: FetchErrorHandlers;
+  onError?: (error: Error, request: Request) => void | Promise<void>;
+  showTrace?: boolean;
+}) => ((request: Request) => Promise<Response>);
+export { fetchHandler as default };

package/dist/handler/http/node-handler.d.ts

@@ -1,9 +1,9 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { HtmlErrorHandlerOptions } from "../../error-handler/html-error-handler.d.ts";
-import type { ErrorHandlers } from "../../error-handler/types.d.d.ts";
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { HtmlErrorHandlerOptions } from "../../error-handler/html-error-handler.js";
+import { E as ErrorHandlers } from "../../packem_shared/types.d-C763gSYq.js";
 declare const nodeHandler: (error: Error, options?: HtmlErrorHandlerOptions & {
-    extraHandlers?: ErrorHandlers;
-    onError?: (error: Error, request: IncomingMessage, response: ServerResponse) => void | Promise<void>;
-    showTrace?: boolean;
-}) => (request: IncomingMessage, response: ServerResponse) => Promise<void>;
-export default nodeHandler;
+  extraHandlers?: ErrorHandlers;
+  onError?: (error: Error, request: IncomingMessage, response: ServerResponse) => void | Promise<void>;
+  showTrace?: boolean;
+}) => ((request: IncomingMessage, response: ServerResponse) => Promise<void>);
+export { nodeHandler as default };

package/dist/index.d.ts

@@ -1,14 +1,12 @@
-export { default as createNegotiatedErrorHandler } from "./error-handler/create-negotiated-error-handler.d.ts";
-export type { HtmlErrorHandlerOptions } from "./error-handler/html-error-handler.d.ts";
-export { htmlErrorHandler } from "./error-handler/html-error-handler.d.ts";
-export type { JsonErrorBody, JsonErrorFormatter, JsonErrorHandlerOptions } from "./error-handler/json-error-handler.d.ts";
-export { jsonErrorHandler } from "./error-handler/json-error-handler.d.ts";
-export { default as jsonapiErrorHandler } from "./error-handler/jsonapi-error-handler.d.ts";
-export type { JsonpErrorBody, JsonpErrorFormatter, JsonpErrorHandlerOptions } from "./error-handler/jsonp-error-handler.d.ts";
-export { jsonpErrorHandler } from "./error-handler/jsonp-error-handler.d.ts";
-export { default as problemErrorHandler } from "./error-handler/problem-error-handler.d.ts";
-export type { TextErrorFormatter, TextErrorHandlerOptions } from "./error-handler/text-error-handler.d.ts";
-export { textErrorHandler } from "./error-handler/text-error-handler.d.ts";
-export type { ApiFormat, ErrorHandler, ErrorHandlers } from "./error-handler/types.d.d.ts";
-export type { ToXmlOptions, XmlErrorBody, XmlErrorFormatter, XmlErrorHandlerOptions } from "./error-handler/xml-error-handler.d.ts";
-export { xmlErrorHandler } from "./error-handler/xml-error-handler.d.ts";
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { E as ErrorHandlers, a as ErrorHandler } from "./packem_shared/types.d-C763gSYq.js";
+export { type A as ApiFormat } from "./packem_shared/types.d-C763gSYq.js";
+export { type HtmlErrorHandlerOptions, htmlErrorHandler } from "./error-handler/html-error-handler.js";
+export { type JsonErrorBody, type JsonErrorFormatter, type JsonErrorHandlerOptions, jsonErrorHandler } from "./error-handler/json-error-handler.js";
+export { default as jsonapiErrorHandler } from "./error-handler/jsonapi-error-handler.js";
+export { type JsonpErrorBody, type JsonpErrorFormatter, type JsonpErrorHandlerOptions, jsonpErrorHandler } from "./error-handler/jsonp-error-handler.js";
+export { default as problemErrorHandler } from "./error-handler/problem-error-handler.js";
+export { type TextErrorFormatter, type TextErrorHandlerOptions, textErrorHandler } from "./error-handler/text-error-handler.js";
+export { type ToXmlOptions, type XmlErrorBody, type XmlErrorFormatter, type XmlErrorHandlerOptions, xmlErrorHandler } from "./error-handler/xml-error-handler.js";
+declare const createNegotiatedErrorHandler: (errorHandlers: ErrorHandlers, showTrace: boolean, defaultHtmlHandler?: ErrorHandler) => (error: Error, request: IncomingMessage, response: ServerResponse) => Promise<void>;
+export { type ErrorHandler, type ErrorHandlers, createNegotiatedErrorHandler };

package/dist/packem_shared/types.d-C763gSYq.d.ts

@@ -0,0 +1,13 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+type ErrorHandler = (error: Error, request: IncomingMessage, response: ServerResponse) => Promise<void> | void;
+type FetchErrorHandler = (error: unknown, request: Request) => Promise<Response>;
+type ErrorHandlers = {
+  handler: ErrorHandler;
+  regex: RegExp;
+}[];
+type FetchErrorHandlers = {
+  handler: FetchErrorHandler;
+  regex: RegExp;
+}[];
+type ApiFormat = "jsonapi" | "problem" | "html";
+export { ApiFormat as A, ErrorHandlers as E, FetchErrorHandlers as F, ErrorHandler as a };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/error-handler",
-  "version": "2.0.0-alpha.11",
+  "version": "2.0.0-alpha.12",
   "description": "Error handlers for use in development and production environments.",
   "keywords": [
     "visulima",
@@ -134,15 +134,15 @@
   ],
   "dependencies": {
     "@tinyhttp/accepts": "^2.3.0",
-    "@visulima/boxen": "3.0.0-alpha.9",
-    "@visulima/error": "6.0.0-alpha.8",
+    "@visulima/boxen": "3.0.0-alpha.10",
+    "@visulima/error": "6.0.0-alpha.13",
     "http-errors": "^2.0.1",
     "http-status-codes": "^2.3.0",
     "jstoxml": "^7.1.0",
     "ts-japi": "^1.12.3"
   },
   "engines": {
-    "node": ">=22.13 <=25.x"
+    "node": "^22.14.0 || >=24.10.0"
   },
   "publishConfig": {
     "access": "public",

package/dist/error-handler/create-negotiated-error-handler.d.ts

@@ -1,4 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { ErrorHandler, ErrorHandlers } from "./types.d.d.ts";
-declare const createNegotiatedErrorHandler: (errorHandlers: ErrorHandlers, showTrace: boolean, defaultHtmlHandler?: ErrorHandler) => (error: Error, request: IncomingMessage, response: ServerResponse) => Promise<void>;
-export default createNegotiatedErrorHandler;

package/dist/error-handler/fetch-create-negotiated-error-handler.d.ts

@@ -1,3 +0,0 @@
-import type { FetchErrorHandlers } from "./types.d.d.ts";
-declare const createFetchNegotiatedErrorHandler: (errorHandlers: FetchErrorHandlers, showTrace: boolean, defaultHtmlHandler?: (error: Error, request: Request) => Promise<Response>) => (error: Error, request: Request) => Promise<Response>;
-export default createFetchNegotiatedErrorHandler;

package/dist/error-handler/fetch-html-error-handler.d.ts

@@ -1,3 +0,0 @@
-import type { HtmlErrorHandlerOptions } from "./html-error-handler.d.ts";
-export declare const fetchHtmlErrorHandler: (options?: HtmlErrorHandlerOptions) => (error: Error, request: Request) => Promise<Response>;
-export default fetchHtmlErrorHandler;

package/dist/error-handler/utils/add-status-code-to-response.d.ts

@@ -1,3 +0,0 @@
-import type { ServerResponse } from "node:http";
-declare const addStatusCodeToResponse: (response: ServerResponse, error: unknown) => void;
-export default addStatusCodeToResponse;

package/dist/error-handler/utils/send-json.d.ts

@@ -1,9 +0,0 @@
-import type { ServerResponse } from "node:http";
-/**
- * Sends a JSON object as the response body.
- * @param response response object
- * @param jsonBody of data
- * @param contentType optional content-type header value
- */
-declare const sendJson: (response: ServerResponse, jsonBody: unknown, contentType?: string) => void;
-export default sendJson;

package/dist/error-handler/utils/set-error-headers.d.ts

@@ -1,3 +0,0 @@
-import type { ServerResponse } from "node:http";
-declare const setErrorHeaders: (response: ServerResponse, error: unknown) => void;
-export default setErrorHeaders;