@honeybadger-io/js 3.2.8 → 4.0.0-beta.2

package/dist/browser/types/browser/util.d.ts

@@ -3,7 +3,7 @@
  * @param {!HTMLElement} element
  * @return {string}
  */
-export declare function stringNameOfElement(element: any): string;
+export declare function stringNameOfElement(element: HTMLElement): string;
 export declare function stringSelectorOfElement(element: any): any;
 export declare function stringTextOfElement(element: any): any;
 export declare function nativeFetch(): boolean;

package/dist/browser/types/core/client.d.ts

@@ -1,9 +1,17 @@
-import { Config, Logger, BeforeNotifyHandler, AfterNotifyHandler, Notice, Noticeable } from './types';
+import { Config, Logger, BeforeNotifyHandler, AfterNotifyHandler, Notice, Noticeable, HoneybadgerStore, BreadcrumbRecord } from './types';
 export default class Client {
+    private __pluginsExecuted;
+    protected __store: HoneybadgerStore<{
+        context: Record<string, unknown>;
+        breadcrumbs: BreadcrumbRecord[];
+    }>;
+    protected __beforeNotifyHandlers: BeforeNotifyHandler[];
+    protected __afterNotifyHandlers: AfterNotifyHandler[];
+    protected __getSourceFileHandler: (path: string, cb: (fileContent: string) => void) => void;
     config: Config;
     logger: Logger;
     constructor(opts?: Partial<Config>);
-    factory(_opts?: Record<string, unknown>): unknown;
+    factory(_opts?: Partial<Config>): Client;
     getVersion(): string;
     configure(opts?: Partial<Config>): Client;
     beforeNotify(handler: BeforeNotifyHandler): Client;
@@ -11,6 +19,18 @@ export default class Client {
     setContext(context: Record<string, unknown>): Client;
     resetContext(context?: Record<string, unknown>): Client;
     clear(): Client;
-    notify(notice: Noticeable, name?: string | Partial<Notice>, extra?: Partial<Notice>): Record<string, unknown> | false | unknown;
+    notify(noticeable: Noticeable, name?: string | Partial<Notice>, extra?: Partial<Notice>): boolean;
+    /**
+     * An async version of {@link notify} that resolves only after the notice has been reported to Honeybadger.
+     * Implemented using the {@link afterNotify} hook.
+     * Rejects if for any reason the report failed to be reported.
+     * Useful in serverless environments (AWS Lambda).
+     */
+    notifyAsync(noticeable: Noticeable, name?: string | Partial<Notice>, extra?: Partial<Notice>): Promise<void>;
+    protected makeNotice(noticeable: Noticeable, name?: string | Partial<Notice>, extra?: Partial<Notice>): Notice | null;
     addBreadcrumb(message: string, opts?: Record<string, unknown>): Client;
+    protected __developmentMode(): boolean;
+    protected __send(_notice: Partial<Notice>): void;
+    protected __buildPayload(notice: Notice): Record<string, Record<string, unknown>>;
+    protected __constructTags(tags: unknown): Array<string>;
 }

package/dist/browser/types/core/store.d.ts

@@ -0,0 +1,7 @@
+import { HoneybadgerStore } from "./types";
+export declare class GlobalStore<T> implements HoneybadgerStore<T> {
+    private store;
+    constructor(store: T);
+    getStore(): T;
+    run<R, TArgs extends never[]>(store: T, callback: (...args: TArgs) => R, ...args: TArgs): R;
+}

package/dist/browser/types/core/types.d.ts

@@ -1,4 +1,6 @@
+/// <reference types="node" />
 import Client from './client';
+import { AsyncLocalStorage } from "async_hooks";
 export interface Logger {
     log(...args: unknown[]): unknown;
     info(...args: unknown[]): unknown;
@@ -16,7 +18,6 @@ export interface Config {
     component?: string;
     action?: string;
     revision?: string;
-    disabled: boolean;
     debug: boolean;
     reportData: boolean;
     breadcrumbsEnabled: boolean | {
@@ -33,13 +34,13 @@ export interface Config {
     enableUnhandledRejection: boolean;
     filters: string[];
     __plugins: Plugin[];
-    tags: any;
+    tags: unknown;
 }
 export interface BeforeNotifyHandler {
-    (notice: Notice): boolean | void;
+    (notice?: Notice): boolean | void;
 }
 export interface AfterNotifyHandler {
-    (error: any, notice: Notice): boolean | void;
+    (error: any, notice?: Notice): boolean | void;
 }
 export interface Plugin {
     load(client: Client): void;
@@ -67,6 +68,7 @@ export interface Notice {
     details: Record<string, Record<string, unknown>>;
     __breadcrumbs: BreadcrumbRecord[];
     afterNotify?: AfterNotifyHandler;
+    [key: string]: unknown;
 }
 export declare type Noticeable = string | Error | Partial<Notice>;
 export interface BacktraceFrame {
@@ -74,6 +76,7 @@ export interface BacktraceFrame {
     method: string;
     number: number;
     column: number;
+    source?: Record<string, string>;
 }
 export interface BreadcrumbRecord {
     category: string;
@@ -87,3 +90,4 @@ export interface CGIData {
     HTTP_COOKIE: string | undefined;
     [x: string]: unknown;
 }
+export declare type HoneybadgerStore<T> = Pick<AsyncLocalStorage<T>, 'getStore' | 'run'>;

package/dist/browser/types/core/util.d.ts

@@ -5,9 +5,10 @@ export declare function mergeNotice(notice1: Partial<Notice>, notice2: Partial<N
 export declare function objectIsEmpty(obj: any): boolean;
 export declare function objectIsExtensible(obj: any): boolean;
 export declare function makeBacktrace(stack: string, shift?: number): BacktraceFrame[];
-export declare function runBeforeNotifyHandlers(notice: any, handlers: BeforeNotifyHandler[]): boolean;
-export declare function runAfterNotifyHandlers(notice: any, handlers: AfterNotifyHandler[], error?: any): boolean;
-export declare function newObject<T>(obj: T): T | Record<string, unknown>;
+export declare function getSourceForBacktrace(backtrace: BacktraceFrame[], getSourceFileHandler: (path: string, cb: (fileContent: string) => void) => void, cb: (sourcePerTrace: Record<string, string>[]) => void): void;
+export declare function runBeforeNotifyHandlers(notice: Notice | null, handlers: BeforeNotifyHandler[]): boolean;
+export declare function runAfterNotifyHandlers(notice: Notice | null, handlers: AfterNotifyHandler[], error?: Error): boolean;
+export declare function shallowClone<T>(obj: T): T | Record<string, unknown>;
 export declare function sanitize(obj: any, maxDepth?: number): any;
 export declare function logger(client: Client): Logger;
 /**
@@ -27,3 +28,4 @@ export declare function generateStackTrace(): string;
 export declare function filter(obj: Record<string, unknown>, filters: string[]): Record<string, unknown>;
 export declare function filterUrl(url: string, filters: string[]): string;
 export declare function formatCGIData(vars: Record<string, unknown>, prefix?: string): Record<string, unknown>;
+export declare function clone<T>(obj: T): T;

package/dist/browser/types/server/async_store.d.ts

@@ -0,0 +1,5 @@
+import { BreadcrumbRecord, HoneybadgerStore } from "../core/types";
+export declare const AsyncStore: HoneybadgerStore<{
+    context: Record<string, unknown>;
+    breadcrumbs: BreadcrumbRecord[];
+}>;

package/dist/browser/types/server.d.ts

@@ -8,6 +8,7 @@ declare class Honeybadger extends Client {
     lambdaHandler: typeof lambdaHandler;
     constructor(opts?: Partial<Config>);
     factory(opts?: Partial<Config>): Honeybadger;
+    run<R>(handler: (...args: never[]) => R, onError?: (...args: any[]) => any): R | void;
 }
 declare const _default: Honeybadger;
 export default _default;

package/dist/server/honeybadger.d.ts

@@ -1,12 +1,14 @@
 import Client from './types/core/client';
 import { Config } from './types/core/types';
-import { errorHandler, requestHandler, lambdaHandler } from './types/server/middleware';
+import { errorHandler, requestHandler } from './types/server/middleware';
+import { lambdaHandler } from './types/server/aws_lambda';
 declare class Honeybadger extends Client {
     errorHandler: typeof errorHandler;
     requestHandler: typeof requestHandler;
     lambdaHandler: typeof lambdaHandler;
     constructor(opts?: Partial<Config>);
     factory(opts?: Partial<Config>): Honeybadger;
+    run<R>(handler: (...args: never[]) => R, onError?: (...args: any[]) => any): R | void;
 }
 declare const _default: Honeybadger;
 export default _default;