@honeybadger-io/react-native 5.2.0 → 6.0.0

package/CHANGELOG.md

@@ -3,6 +3,54 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 6.0.0 (2023-06-07)
+
+
+### ⚠ BREAKING CHANGES
+
+* **react-native:** include the features of the core js project (#1069)
+
+### Features
+
+* **react-native:** include the features of the core js project ([#1069](https://github.com/honeybadger-io/honeybadger-js/issues/1069)) ([a956508](https://github.com/honeybadger-io/honeybadger-js/commit/a956508272bdec340e6c93cf3e1f38ad4028cbfd))
+
+## 5.2.0 (2023-03-27)
+
+## 5.1.6 (2023-03-14)
+
+## 5.1.4 (2023-02-27)
+
+## 5.1.1 (2023-02-13)
+
+## 5.0.0 (2023-02-05)
+
+## 4.10.0 (2023-02-05)
+
+
+### ⚠ BREAKING CHANGES
+
+* specify "engines" in package.json
+
+### Features
+
+* **rollup-plugin:** add rollup/vite plugin that uploads sourcemaps to honeybadger API ([850b2b5](https://github.com/honeybadger-io/honeybadger-js/commit/850b2b5740d960e7e533b848c09c62a9bb9f63cb))
+* specify "engines" in package.json ([d0eb1a3](https://github.com/honeybadger-io/honeybadger-js/commit/d0eb1a368b9904d464528a61844fa52416d14828)), closes [#961](https://github.com/honeybadger-io/honeybadger-js/issues/961)
+
+## 4.8.2 (2023-01-02)
+
+## 4.8.0 (2022-12-12)
+
+## 4.7.1 (2022-11-14)
+
+## 4.7.0 (2022-11-01)
+
+
+### Features
+
+* migrate honeybadger-react-native to monorepo ([#901](https://github.com/honeybadger-io/honeybadger-js/issues/901)) ([46f3d7e](https://github.com/honeybadger-io/honeybadger-js/commit/46f3d7e0db7c4c18698fb2044802351efbbdbab9))
+
+
+
 ## [5.2.0](https://github.com/honeybadger-io/honeybadger-js/compare/v5.1.7...v5.2.0) (2023-03-27)
 
 **Note:** Version bump only for package @honeybadger-io/react-native

package/README.md

@@ -8,14 +8,14 @@ A React Native library for integrating [Honeybadger](https://honeybadger.io) int
 
 ## Installation
 
-From the root directory of your React Native project:
+From the root directory of your React Native project, add *@honeybadger-io/react-native* as a dependency:
 
 ```shell
 npm install "@honeybadger-io/react-native"
 cd ios && pod install
 ```
 
-The above will download the Honeybadger React Native library and add it as a dependency of your project. The iOS step is required to properly add the library to the Xcode project through CocoaPods. Android doesn't require a separate step.
+The iOS step is required to properly add the library to the Xcode project through CocoaPods. Android doesn't require a separate step.
 
 ## Initialization
 
@@ -25,86 +25,32 @@ Add the following to your **App.js** file to initialize the Honeybadger library.
 import Honeybadger from "@honeybadger-io/react-native";
 
 export default function App() {
-  Honeybadger.configure("{{PROJECT_API_KEY}}");
+  Honeybadger.configure({
+    apiKey: '[ YOUR API KEY HERE ]'
+  })
   // ...
 }
 ```
 
-You can log into your [Honeybadger](https://honeybadger.io) account to obtain your API key.
+You can log into your [Honeybadger](https://app.honeybadger.io/) account to obtain your API key.
 
 
 ## Configuration
+See the [Configuration Reference](https://docs.honeybadger.io/lib/javascript/reference/configuration/) for a full list of config options. 
 
-The configure method takes additional configuration options.
+## Usage
 
-| Name         | Type    | Required | Default | Example              |
-|--------------|---------|----------|---------|----------------------|
-| apiKey       | String  | YES      | `""`    | `"hb-api-key-1234"`  |
-| reportErrors | Boolean | NO       | true    |                      |
-| revision     | String  | NO       | `""`    | `"8afb34a"`          |
-| projectRoot  | String  | NO       | `""`    | `"/path/to/project"` |
+Uncaught iOS, Android, and JavaScript errors will be automatically reported to Honeybadger by default. 
 
-```js
-  Honeybadger.configure(
-    "hb-api-key-1234",
-    "8afb34a",
-    "/path/to/project"
-  );
-```
-
-The **reportErrors** parameter determines if errors are to be sent to Honeybadger. This is set to **true** by default. In certain environments, say, during development, it could be useful to set **reportErrors** to **false** to prevent errors from being posted to your Honeybadger account.
-
-
-## Usage Examples
-
-iOS, Android, and JavaScript errors will be automatically handled by the Honeybadger React Native library, by default. But you can also use the following API to customize error handling in your application.
-
-### Honeybadger.notify(error, additionalData)
-
-You can use the **notify** method to send any kind of error, exception, object, String, etc. If sending an error or exception, the Honeybadger React Native library will attempt to extract a stack trace and any relevant information that might be useful. You can also optionally provide **additionalData** to the **notify** method, as either a string or an object, to include any relevant information.
-
-### Honeybadger.setContext(context)
-
-If you have data that you would like to include whenever an error or an exception occurs, you can provide that data using the **setContext** method. Provide an object as an argument. You can call **setContext** as many times as needed. New context data will be merged with any previously-set context data.
-
-```js
-Honeybadger.setContext({
-  user_id: "123abc",
-  more: "some additional data",
-});
-```
-
-### Honeybadger.resetContext()
-
-If you've used **Honeybadger.setContext()** to store context data, you can use **Honeybadger.resetContext()** to clear that data.
-
-### Honeybadger.setLogLevel(logLevel)
-
-Sets the logging level for the Honeybadger library. 
-
-```js
-  Honeybadger.setLogLevel("debug");
-```
-
-The following values are accepted:
+You can also [report errors](https://docs.honeybadger.io/lib/javascript/guides/reporting-errors/) yourself using `Honeybadger.notify()`. 
 
-| Value     | Meaning                                  |
-|-----------|------------------------------------------|
-| "debug"   | Everything will be logged to console.    |
-| "warning" | Only warnings will be logged to console. |
-| "error"   | Only errors will be logged to console.   |
+Error reports can be [customized](https://docs.honeybadger.io/lib/javascript/guides/customizing-error-reports/), for example by using `Honeybadger.setContext()`, `Honeybadger.addBreadcrumb()`, and `Honeybadger.beforeNotify()`. 
 
-The default logging level is "warning".
+### Limitations
+Some native errors on Android may not be recorded if they cause an immediate crash of the app before the notice makes it to Honeybadger. 
 
-## Source Maps
-
-This package includes a script that will help you generate source maps for your project. To generate source maps for both iOS and Android, run the following from your project root directory.
-
-```shell
-npx honeybadger-generate-sourcemaps
-```
-
-The operation might take some time, as React Native needs to build production-ready bundles and their respective source map files for both iOS and Android. Upon completion, you will find the **sourcemap-ios** and **sourcemap-android** files in your project root directory. You can then [upload these files to Honeybadger](https://docs.honeybadger.io/lib/javascript/guides/using-source-maps.html) to view descriptive stack trace symbols in your production builds.
+### Source Maps
+The procedure to generate and upload sourcemaps for react-native is currently [under development](https://github.com/honeybadger-io/honeybadger-js/issues/1029).
 
 ## Example Projects
 
@@ -113,19 +59,30 @@ The **examples** directory contains two minimal React Native projects, demonstra
 ### react-native-cli
 ```shell
 npm install
-cd ios && pod install && cd ..
-npx react-native start
+npm run ios:install
+npm start
 ```
 In a new shell:
 ```
-npx react-native run-ios
+npm run ios
 ```
 or
 ```
-npx react-native run-android
+npm run android
+```
+
+If you want to test a release (ie prod) build, use 
+```shell
+npm run ios:release
+```
+or
+```shell
+npm run android:release
 ```
 
 ### expo-app
+Do not use `npx expo start`, since this relies on Expo Go, which [does not support custom native code](https://docs.expo.dev/bare/using-expo-client/). Instead, use the following commands:
+
 ```shell
 npm install
 npm run ios
@@ -138,6 +95,30 @@ npm run android
 
 When the app opens, enter your API key, press "Configure", and then test your setup by using the button to throw an error. 
 
+If you want to test a release (ie prod) build, use 
+```shell
+npm run ios:release
+```
+or
+```shell
+npm run android:release
+```
+
+### Development workflow
+When developing the react-native package and testing against the example projects, you will need to change the dependency in the example project's `package.json`. Rather than `"@honeybadger-io/react-native": "latest"`, you'll want to generate a tarball of the `react-native` package and install it. For example:
+
+In the `react-native` folder: 
+```shell
+npm run build && npm pack
+```
+This will generate a tarball. Install it in an example project by updating `package.json`, for example:
+```json
+"@honeybadger-io/react-native": "file:../../honeybadger-io-react-native-5.1.6.tgz"
+```
+Then run `npm install` within the example project. 
+
+If you notice that your changes are not being picked up, there may be a caching issue. You can bust this by renaming the tarball to a unique name and re-installing it. 
+
 ## License
 
 The Honeybadger React Native library is MIT-licensed. See the [MIT-LICENSE](./MIT-LICENSE) file in this folder for details.

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { Client, Types } from '@honeybadger-io/core';
+
+declare class Honeybadger extends Client {
+    private __jsHandlerInitialized;
+    private __nativeHandlerInitialized;
+    private __originalJsHandler;
+    constructor(opts?: Partial<Types.Config>);
+    configure(opts?: Partial<Types.Config>): this;
+    factory(opts?: Partial<Types.BrowserConfig>): this;
+    checkIn(): Promise<void>;
+    showUserFeedbackForm(): Promise<void>;
+    private setJavascriptErrorHandler;
+    private setNativeExceptionHandler;
+    private onNativeException;
+    private onNativeIOSException;
+    private onNativeAndroidException;
+}
+declare const _default: Honeybadger;
+
+export { _default as default };

package/dist/index.js

@@ -0,0 +1,379 @@
+'use strict';
+
+var reactNative = require('react-native');
+var core = require('@honeybadger-io/core');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+var name = "@honeybadger-io/react-native";
+var version = "6.0.0";
+var repository = {
+	type: "git",
+	url: "git@github.com:honeybadger-io/honeybadger-js.git"
+};
+
+var Transport = /** @class */ (function () {
+    function Transport() {
+    }
+    Transport.prototype.send = function (options, payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var params, res, resBody;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        payload.notifier = {
+                            name: name,
+                            url: repository.url,
+                            version: version,
+                        };
+                        params = {
+                            method: options.method,
+                            headers: __assign(__assign({}, options.headers), { 'User-Agent': this.buildUserAgent() }),
+                            body: JSON.stringify(core.Util.sanitize(payload, options.maxObjectDepth))
+                        };
+                        return [4 /*yield*/, fetch(options.endpoint, params)];
+                    case 1:
+                        res = _a.sent();
+                        return [4 /*yield*/, res.text()];
+                    case 2:
+                        resBody = _a.sent();
+                        return [2 /*return*/, {
+                                statusCode: res.status,
+                                body: resBody
+                            }];
+                }
+            });
+        });
+    };
+    Transport.prototype.buildUserAgent = function () {
+        var reactNativeVersion = reactNative.Platform.constants.reactNativeVersion.major + "." + reactNative.Platform.constants.reactNativeVersion.minor + "." + reactNative.Platform.constants.reactNativeVersion.patch;
+        var nativePlatform;
+        if (reactNative.Platform.OS === 'ios') {
+            var nativePlatformName = reactNative.Platform.constants.systemName || 'iOS';
+            nativePlatform = nativePlatformName + " " + reactNative.Platform.constants.osVersion;
+        }
+        else {
+            nativePlatform = 'Android';
+        }
+        return name + " " + version + "; " + reactNativeVersion + "; " + nativePlatform;
+    };
+    return Transport;
+}());
+
+function errorMessageFromIosException(data) {
+    if (!data) {
+        return '';
+    }
+    if (data.localizedDescription) {
+        var localizedDescription = data.localizedDescription;
+        var startOfNativeIOSCallStack = localizedDescription.indexOf('callstack: (\n');
+        if (startOfNativeIOSCallStack === -1) {
+            var lines = localizedDescription.split('\n');
+            return lines.length === 0 ? localizedDescription : lines[0].trim();
+        }
+        else {
+            return localizedDescription.substring(0, startOfNativeIOSCallStack).trim();
+        }
+    }
+    else if (data.name || data.reason) {
+        return (data.name + " : " + data.reason).trim();
+    }
+    else {
+        return '';
+    }
+}
+function backtraceAndDetailsFromIosException(data) {
+    var framesFromComponent = framesFromComponentStack(data.localizedDescription);
+    var framesFromReactNativeIos = framesFromReactNativeIosStack(data);
+    var framesFromIosCall = framesFromIOSCallStack(data);
+    var backtrace = [];
+    var backtraceDetails = {};
+    if (framesFromComponent.length) {
+        backtrace = framesFromComponent;
+        backtraceDetails.primaryBackTraceSource = 'ReactNativeComponentStack';
+        if (framesFromReactNativeIos.length) {
+            backtraceDetails.reactNativeIOSStackTrace = framesFromReactNativeIos;
+        }
+        if (framesFromIosCall.length) {
+            backtraceDetails.iosCallStack = framesFromIosCall;
+        }
+    }
+    else if (framesFromReactNativeIos.length) {
+        backtrace = framesFromReactNativeIos;
+        backtraceDetails.primaryBackTraceSource = 'ReactNativeIOSStackTrace';
+        if (framesFromIosCall.length) {
+            backtraceDetails.iosCallStack = framesFromIosCall;
+        }
+    }
+    else if (framesFromIosCall.length) {
+        backtrace = framesFromIosCall;
+        backtraceDetails.primaryBackTraceSource = 'iOSCallStack';
+    }
+    return { backtrace: backtrace, backtraceDetails: backtraceDetails };
+}
+function framesFromComponentStack(str) {
+    str = str || '';
+    var frames = [];
+    var regex = /^\s*in\s(\S+)(\s\(at\s(\S+):(\S+)\)\s*$)?/gm;
+    var match;
+    while ((match = regex.exec(str)) !== null) {
+        if (match.index === regex.lastIndex) {
+            regex.lastIndex++;
+        }
+        frames.push({
+            method: match && match.length > 1 ? match[1] : '',
+            file: match && match.length > 3 ? match[3] : '',
+            number: match && match.length > 4 ? match[4] : '',
+        });
+    }
+    return frames;
+}
+function framesFromReactNativeIosStack(data) {
+    if (!data.reactNativeStackTrace) {
+        return [];
+    }
+    return data.reactNativeStackTrace.map(function (frame) { return ({
+        method: frame.methodName || '',
+        number: frame.lineNumber || '',
+        file: frame.file || '',
+        column: frame.column || '',
+    }); });
+}
+function framesFromIOSCallStack(data) {
+    var callStack = [];
+    if (data.localizedDescription && typeof data.localizedDescription === 'string') {
+        callStack = data.localizedDescription.split('\n').map(function (item) { return item.trim(); });
+    }
+    else if (Array.isArray(data.callStackSymbols) && data.callStackSymbols.length) {
+        callStack = data.callStackSymbols.map(function (item) { return item.trim(); });
+    }
+    var frames = [];
+    var regex = /\d+\s+(\S+)\s+(\S+)\s(.+)\s\+\s(\d+)(\s+\((\S+):(\S+)\))?/gm;
+    var match;
+    callStack.forEach(function (element) {
+        while ((match = regex.exec(element)) !== null) {
+            if (match.index === regex.lastIndex) {
+                regex.lastIndex++;
+            }
+            var moduleName = match && match.length > 1 ? match[1] : '';
+            var stackAddress = match && match.length > 2 ? match[2] : '';
+            var loadAddress = match && match.length > 3 ? match[3] : '';
+            var file = match && match.length > 6 ? match[6] : '';
+            var line = match && match.length > 7 ? match[7] : '';
+            // TODO: Why doesn't this match the BacktraceFrame type?
+            frames.push({
+                file: file || moduleName || '',
+                line: line || '',
+                method: loadAddress || '',
+                stack_address: stackAddress || '',
+            });
+        }
+    });
+    return frames;
+}
+
+function backtraceFromAndroidException(data) {
+    if (!data || !data.stackTrace)
+        return [];
+    function isStringWithValue(val) {
+        return typeof val === 'string' && val.trim().length > 0;
+    }
+    return data.stackTrace.map(function (frame) {
+        var method = (isStringWithValue(frame.class) && isStringWithValue(frame.method))
+            ? frame.class + "." + frame.method
+            : frame.method;
+        return {
+            method: method || '',
+            file: frame.file || '',
+            number: frame.line || ''
+        };
+    });
+}
+
+var Honeybadger = /** @class */ (function (_super) {
+    __extends(Honeybadger, _super);
+    function Honeybadger(opts) {
+        if (opts === void 0) { opts = {}; }
+        var _this = _super.call(this, mergeDefaultOpts(opts), new Transport()) || this;
+        _this.__jsHandlerInitialized = false;
+        _this.__nativeHandlerInitialized = false;
+        _this.setContext({
+            platform: {
+                os: reactNative.Platform.OS,
+                version: reactNative.Platform.Version
+            }
+        });
+        return _this;
+    }
+    Honeybadger.prototype.configure = function (opts) {
+        if (opts === void 0) { opts = {}; }
+        this.setJavascriptErrorHandler();
+        this.setNativeExceptionHandler();
+        return _super.prototype.configure.call(this, mergeDefaultOpts(opts));
+    };
+    Honeybadger.prototype.factory = function (opts) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new Honeybadger(opts);
+    };
+    Honeybadger.prototype.checkIn = function () {
+        throw new Error('Honeybadger.checkIn() is not yet supported on react-native');
+    };
+    Honeybadger.prototype.showUserFeedbackForm = function () {
+        throw new Error('Honeybadger.showUserFeedbackForm() is not yet supported on react-native');
+    };
+    Honeybadger.prototype.setJavascriptErrorHandler = function () {
+        var _this = this;
+        if (this.__jsHandlerInitialized) {
+            return;
+        }
+        this.logger.debug('Setting up the JavaScript global error handler.');
+        this.__originalJsHandler = ErrorUtils.getGlobalHandler();
+        ErrorUtils.setGlobalHandler(function (err, isFatal) {
+            _this.logger.debug('JavaScript global error handler triggered.');
+            _this.notify(err);
+            // Allowing the default error handler to process the error after
+            // we're done with it will show the useful RN red info box in dev.
+            // However in prod it causes duplicate errors to be reported on iOS
+            // since the default handler re-throws a native error
+            if (__DEV__ && _this.__originalJsHandler) {
+                _this.logger.debug('Passing error to previous error handler.');
+                _this.__originalJsHandler(err, isFatal);
+            }
+        });
+        this.__jsHandlerInitialized = true;
+    };
+    Honeybadger.prototype.setNativeExceptionHandler = function () {
+        if (this.__nativeHandlerInitialized) {
+            return;
+        }
+        var HoneybadgerNativeModule = reactNative.NativeModules.HoneybadgerReactNative;
+        if (!HoneybadgerNativeModule) {
+            this.logger.error('The native module was not found. Please review the installation instructions.');
+            return;
+        }
+        HoneybadgerNativeModule.start();
+        var nativeEventEmitter = new reactNative.NativeEventEmitter(HoneybadgerNativeModule);
+        nativeEventEmitter.addListener('native-exception-event', this.onNativeException.bind(this));
+        this.__nativeHandlerInitialized = true;
+    };
+    Honeybadger.prototype.onNativeException = function (data) {
+        switch (reactNative.Platform.OS) {
+            case 'ios':
+                this.onNativeIOSException(data);
+                break;
+            case 'android':
+                this.onNativeAndroidException(data);
+                break;
+        }
+    };
+    Honeybadger.prototype.onNativeIOSException = function (data) {
+        var _a = backtraceAndDetailsFromIosException(data), backtrace = _a.backtrace, backtraceDetails = _a.backtraceDetails;
+        var notice = {
+            name: "React Native iOS " + data.type,
+            message: errorMessageFromIosException(data),
+            backtrace: backtrace,
+            details: __assign({ errorDomain: data.errorDomain || '', initialHandler: data.initialHandler || '', userInfo: data.userInfo || {}, architecture: data.architecture || '' }, backtraceDetails),
+        };
+        this.notify(notice);
+    };
+    Honeybadger.prototype.onNativeAndroidException = function (data) {
+        var notice = {
+            name: "React Native Android " + data.type,
+            message: data.message || '',
+            details: {
+                errorDomain: data.errorDomain || '',
+                initialHandler: data.initialHandler || '',
+                userInfo: data.userInfo || {},
+                architecture: data.architecture || '',
+            },
+            backtrace: backtraceFromAndroidException(data)
+        };
+        this.notify(notice);
+    };
+    return Honeybadger;
+}(core.Client));
+function mergeDefaultOpts(opts) {
+    return __assign({ environment: __DEV__ ? 'development' : 'production' }, opts);
+}
+var index = new Honeybadger();
+
+module.exports = index;
+//# sourceMappingURL=index.js.map