@honeybadger-io/js 6.16.4 → 6.16.5

package/dist/browser/honeybadger.js

@@ -1455,7 +1455,7 @@
 	        this.__notifier = {
 	            name: '@honeybadger-io/core',
 	            url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/core',
-	            version: '6.16.4'
+	            version: '6.16.5'
 	        };
 	        this.config = __assign$1(__assign$1({}, defaults_1.CONFIG), opts);
 	        this.__initStore();
@@ -2883,6 +2883,104 @@
 	}());
 	feedbackForm.BrowserFeedbackForm = BrowserFeedbackForm;
 
+	var globalSingleton = {};
+
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.getOrCreateSingleton = exports.singletonKey = exports.DISABLE_GLOBAL_SINGLETON_KEY = void 0;
+		var core_1 = src;
+		/**
+		 * Set this on the global object before the package is loaded to opt out of sharing.
+		 * Two independently bundled copies on one page then keep their own clients, the way
+		 * they did before the singleton was shared.
+		 */
+		exports.DISABLE_GLOBAL_SINGLETON_KEY = '__HONEYBADGER_DISABLE_GLOBAL_SINGLETON__';
+		/**
+		 * Stamped on the client when it is stored, and required when it is read back, so the slot
+		 * is only ever trusted when this package wrote it. Duck typing would not do: a value that
+		 * happens to carry a `notify` method would be handed out as the client.
+		 */
+		var CLIENT_MARKER = '__honeybadger_client__';
+		function singletonKey(target, version) {
+		    return "__honeybadger_singleton_".concat(target, "_").concat(version, "__");
+		}
+		exports.singletonKey = singletonKey;
+		function isSingleton(value) {
+		    return !!value && value[CLIENT_MARKER] === true;
+		}
+		function markAsSingleton(client) {
+		    Object.defineProperty(client, CLIENT_MARKER, {
+		        value: true,
+		        writable: false,
+		        configurable: true,
+		        enumerable: false,
+		    });
+		}
+		/**
+		 * Returns the client stored on the global object, creating and storing it the first time.
+		 *
+		 * Bundlers can emit more than one copy of this module — Next.js compiles the
+		 * instrumentation, page-rendering and edge contexts into separate module graphs — and
+		 * each copy would otherwise build its own client. Only the copy the configuration code
+		 * ran in would be configured, so a `Honeybadger.notify()` made through any other copy
+		 * would silently do nothing. Keeping the instance on the realm's global object lets every
+		 * copy find the same configured client.
+		 *
+		 * The slot is keyed by build target and by exact version: an older copy must never be
+		 * handed to a newer caller that would then call a method it does not have. Two different
+		 * versions in one realm fall back to one client each, which is the behaviour that shipped
+		 * before the singleton was shared.
+		 */
+		function getOrCreateSingleton(target, version, create, _global) {
+		    if (_global === void 0) { _global = core_1.Util.globalThisOrWindow(); }
+		    if (!_global) {
+		        return create();
+		    }
+		    var key = singletonKey(target, version);
+		    var shared;
+		    var canShare = false;
+		    // Reading the global object can throw as easily as writing to it can: the opt-out
+		    // flag, the slot and the marker are all ordinary properties, and a host or another
+		    // script may have installed a getter on any of them. `create()` stays outside, so a
+		    // genuine failure to build the client still propagates.
+		    try {
+		        if (_global[exports.DISABLE_GLOBAL_SINGLETON_KEY] !== true) {
+		            canShare = true;
+		            var existing = _global[key];
+		            if (isSingleton(existing)) {
+		                shared = existing;
+		            }
+		        }
+		    }
+		    catch (_e) {
+		        canShare = false;
+		    }
+		    if (shared) {
+		        return shared;
+		    }
+		    var created = create();
+		    if (!canShare) {
+		        return created;
+		    }
+		    try {
+		        markAsSingleton(created);
+		        Object.defineProperty(_global, key, {
+		            value: created,
+		            writable: true,
+		            configurable: true,
+		            enumerable: false,
+		        });
+		    }
+		    catch (_e) {
+		        // A frozen global object (node --frozen-intrinsics, SES lockdown). Importing this
+		        // package must never throw, so this copy keeps the client to itself.
+		    }
+		    return created;
+		}
+		exports.getOrCreateSingleton = getOrCreateSingleton;
+		
+	} (globalSingleton));
+
 	(function (exports) {
 		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
 		    var extendStatics = function (d, b) {
@@ -2960,6 +3058,7 @@
 		var event_listeners_1 = __importDefault(event_listeners);
 		var transport_1 = transport;
 		var feedback_form_1 = feedbackForm;
+		var global_singleton_1 = globalSingleton;
 		var merge = core_1.Util.merge, filter = core_1.Util.filter, objectIsExtensible = core_1.Util.objectIsExtensible, globalThisOrWindow = core_1.Util.globalThisOrWindow;
 		var getProjectRoot = function () {
 		    var global = globalThisOrWindow();
@@ -3156,7 +3255,7 @@
 		var NOTIFIER = {
 		    name: '@honeybadger-io/js',
 		    url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/js',
-		    version: '6.16.4'
+		    version: '6.16.5'
 		};
 		var userAgent = function () {
 		    if (typeof navigator !== 'undefined') {
@@ -3164,17 +3263,20 @@
 		    }
 		    return "Honeybadger JS Browser Client ".concat(NOTIFIER.version, "; n/a; n/a");
 		};
-		var singleton = new Honeybadger({
-		    __plugins: [
-		        (0, onerror_1.onError)(),
-		        (0, onunhandledrejection_1.default)(),
-		        (0, timers_1.default)(),
-		        (0, event_listeners_1.default)(),
-		        (0, breadcrumbs_1.default)(),
-		        core_1.Plugins.consoleEvents(),
-		    ]
+		var singleton = (0, global_singleton_1.getOrCreateSingleton)('browser', NOTIFIER.version, function () {
+		    var client = new Honeybadger({
+		        __plugins: [
+		            (0, onerror_1.onError)(),
+		            (0, onunhandledrejection_1.default)(),
+		            (0, timers_1.default)(),
+		            (0, event_listeners_1.default)(),
+		            (0, breadcrumbs_1.default)(),
+		            core_1.Plugins.consoleEvents(),
+		        ]
+		    });
+		    client.setNotifier(NOTIFIER);
+		    return client;
 		});
-		singleton.setNotifier(NOTIFIER);
 		var core_2 = src;
 		Object.defineProperty(exports, "Types", { enumerable: true, get: function () { return core_2.Types; } });
 		exports.default = singleton;