@emoyly/problem 8.0.4 → 8.0.6

package/cjs/middleware/axios.d.ts

@@ -2,12 +2,12 @@ import type { PartialMiddlewareOptions } from '../typings/middleware.js';
 import { MiddlewareBase } from './base.js';
 type InterceptorArray = [undefined, (error: unknown) => Promise<never>];
 export declare class AxiosMiddleware extends MiddlewareBase {
-    name: string;
+    readonly name = "axios";
     constructor(options?: PartialMiddlewareOptions);
-    interceptor: (error: unknown) => Promise<never>;
+    private readonly interceptor;
     /**
      * @example instance.interceptors.response.use(...middleware.use())
      */
-    use: () => InterceptorArray;
+    readonly use: () => InterceptorArray;
 }
 export {};

package/cjs/middleware/base.d.ts

@@ -5,30 +5,26 @@ import type { MiddlewareOptions, PartialMiddlewareOptions, ProblemListener } fro
  * Middleware collects errors from somewhere, transforms them into something recognizable by a parser, and then passes them to the parsers, and then returns an array of Problems to whatever is using the middleware
  */
 export declare abstract class MiddlewareBase {
-    options: MiddlewareOptions;
-    abstract name: string;
+    readonly options: MiddlewareOptions;
+    abstract readonly name: string;
     /**
      * When nothing is returned from the parsers, just throw in a default "fallback" Problem object, so that a Problem is still actually returned/emitted
      */
-    enableFallback: boolean;
+    readonly enableFallback: boolean;
     constructor(defaultOptions: MiddlewareOptions, options?: PartialMiddlewareOptions);
-    /**
-     * Call this function when you want to use the middleware function
-     */
-    abstract use(): unknown;
     /**
      * Parse input using parsers
      */
-    parse: (input: unknown) => Problem[];
-    fallback: ProblemOpts;
-    problemListeners: ProblemListener[];
+    protected readonly parse: (input: unknown) => Problem[];
+    protected readonly fallback: ProblemOpts;
+    protected readonly problemListeners: ProblemListener[];
     protected emit: (list: Problem[]) => void;
     /**
      * Listen to problems
      */
-    onProblem: (listener: ProblemListener) => void;
+    readonly onProblem: (listener: ProblemListener) => void;
     /**
      * Un-listen to problems
      */
-    offProblem: (listener: ProblemListener) => void;
+    readonly offProblem: (listener: ProblemListener) => void;
 }

package/cjs/middleware/base.js

@@ -26,7 +26,6 @@ class MiddlewareBase {
                 return [new problem_js_1.Problem({
                         ...this.fallback,
                         'errorObject': input,
-                        'stack': (typeof input === 'object' && input !== null && 'stack' in input && typeof input.stack === 'string') ? input.stack : undefined,
                         'source': `middleware:${this.name}`
                     })];
             return [];

package/cjs/middleware/express.d.ts

@@ -2,18 +2,18 @@ import type { NextFunction, Request, Response } from 'express';
 import type { PartialMiddlewareOptions } from '../typings/middleware.js';
 import { MiddlewareBase } from './base.js';
 export declare class ExpressMiddleware extends MiddlewareBase {
-    name: string;
-    middleware: (error: unknown, req: Request, res: Response, next: NextFunction) => void;
+    readonly name = "express";
+    private middleware;
     /**
      * This function applies the middleware to your Express application. Put this at the very end of your middleware/routes.
      * If you want to also handle 404 errors, check out the notFound middleware function.
      * @example app.use(middleware.use())
      */
-    use: () => (error: unknown, req: Request, res: Response, next: NextFunction) => void;
+    readonly use: () => (error: unknown, req: Request, res: Response, next: NextFunction) => void;
     constructor(options?: PartialMiddlewareOptions);
     /**
      * Put this right before the middleware.use() to catch all 404 errors and respond with a Problem instead of the default Express response
      * @example app.use(middleware.notFound)
      */
-    notFound: (req: Request, res: Response, next: NextFunction) => void;
+    readonly notFound: (req: Request, res: Response, next: NextFunction) => void;
 }

package/cjs/problem.d.ts

@@ -6,7 +6,7 @@ export declare class Problem extends Error implements IProblem {
     detail: string | undefined;
     instance: string | undefined;
     errorObject?: unknown;
-    readonly __problemVersion = "8.0.4";
+    readonly __problemVersion = "8.0.6";
     data: unknown;
     source?: string;
     constructor(opts: ProblemOpts);