@bugban/js 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 // src/env.ts
 var SDK_NAME = "bugban-js";
-var SDK_VERSION = "1.0.0";
+var SDK_VERSION = "1.0.1";
 var isBrowser = (() => {
   try {
     return typeof window !== "undefined" && typeof window.document !== "undefined";
@@ -143,9 +143,21 @@ function section(value, defaults, defaultOn) {
 }
 var CONSOLE_DEFAULTS = {
   levels: ["log", "info", "warn", "error", "debug"],
-  // Only console.error becomes an event. console.warn is far too noisy in a
-  // typical app — React alone emits several per render in development.
-  captureAsEvent: ["error"]
+  /**
+   * Whether console.error becomes an event of its own, or stays a breadcrumb.
+   *
+   * Browser: yes. Most real front-end failures never reach window.onerror —
+   * the app catches the error, logs it, and renders "something went wrong".
+   * console.error is the only signal those leave behind.
+   *
+   * Node: no. Server frameworks log every error they handle, so capturing the
+   * log too reports the same failure twice AND defeats filtering: NestJS logs
+   * a deliberate 404 that the exception filter correctly skipped, and the
+   * console path turned it back into an event. Observed exactly that. The
+   * framework adapter already reports real errors with route context, so here
+   * the console is breadcrumbs only.
+   */
+  captureAsEvent: isBrowser ? ["error"] : []
 };
 var NETWORK_DEFAULTS = {
   enabled: true,
@@ -333,7 +345,7 @@ var Transport = class {
         const nav = navigator;
         if (typeof nav.sendBeacon !== "function") return false;
         const blob = new Blob([JSON.stringify({ ...body, _key: this.apiKey })], {
-          type: "application/json"
+          type: "text/plain;charset=UTF-8"
         });
         return nav.sendBeacon(url, blob);
       }, false);
@@ -892,6 +904,12 @@ var LEVEL_MAP = {
   warn: "warning",
   error: "error"
 };
+function hasErrorArg(args) {
+  for (const a of args) {
+    if (a instanceof Error) return true;
+  }
+  return false;
+}
 function installConsole(opts, hooks) {
   if (typeof console === "undefined") return () => {
   };
@@ -909,7 +927,15 @@ function installConsole(opts, hooks) {
           const message = args.map((a) => typeof a === "string" ? a : truncate(a, 200)).join(" ");
           hooks.breadcrumb(level, truncate(message, 500), args);
           if ((method === "error" || method === "warn") && opts.captureAsEvent.indexOf(method) !== -1) {
-            hooks.capture(level, message, args);
+            if (hasErrorArg(args)) {
+              const deferred = () => safe(() => hooks.capture(level, message, args));
+              safe(() => {
+                const t = setTimeout(deferred, 50);
+                if (t && typeof t.unref === "function") t.unref();
+              });
+            } else {
+              hooks.capture(level, message, args);
+            }
           }
           inside = false;
         }
@@ -1322,6 +1348,12 @@ var BugbanClient = class {
     this.flushTimer = null;
     /** Guard against reporting an error that our own reporting caused. */
     this.sending = false;
+    /**
+     * Error objects already reported, so a throw seen by two handlers is only
+     * sent once. A WeakSet holds no strong reference, so entries disappear with
+     * the errors themselves and this can never grow into a leak.
+     */
+    this.seen = /* @__PURE__ */ new WeakSet();
     this.started = false;
     this.opts = resolveOptions(options);
     this.transport = new Transport(this.opts.host, this.opts.apiKey, this.opts.debug);
@@ -1477,6 +1509,10 @@ var BugbanClient = class {
   capture(error, extra = {}) {
     if (!this.opts.enabled) return;
     if (this.sending) return;
+    if (typeof error === "object" && error !== null) {
+      if (this.seen.has(error)) return;
+      safe(() => this.seen.add(error));
+    }
     safe(() => {
       var _a;
       const norm = normalizeError(error);
@@ -1626,40 +1662,62 @@ var BugbanClient = class {
 };
 
 // src/index.ts
-var client = null;
+var SINGLETON_KEY = "__bugban_client__";
+function readClient() {
+  var _a;
+  return (_a = safe(() => {
+    var _a2;
+    return (_a2 = globalThis[SINGLETON_KEY]) != null ? _a2 : null;
+  }, null)) != null ? _a : null;
+}
+function writeClient(value) {
+  safe(() => {
+    globalThis[SINGLETON_KEY] = value;
+  });
+}
 function init(options = {}) {
-  if (client) safe(() => client.close());
-  client = new BugbanClient(options);
-  client.start();
-  return client;
+  const previous = readClient();
+  if (previous) safe(() => previous.close());
+  const created = new BugbanClient(options);
+  writeClient(created);
+  created.start();
+  return created;
 }
 function getClient() {
-  return client;
+  return readClient();
 }
 function capture(error, extra) {
-  client == null ? void 0 : client.capture(error, extra);
+  var _a;
+  (_a = readClient()) == null ? void 0 : _a.capture(error, extra);
 }
 function captureMessage(message, level = "info") {
-  client == null ? void 0 : client.captureMessage(message, level);
+  var _a;
+  (_a = readClient()) == null ? void 0 : _a.captureMessage(message, level);
 }
 function setUser(user) {
-  client == null ? void 0 : client.setUser(user);
+  var _a;
+  (_a = readClient()) == null ? void 0 : _a.setUser(user);
 }
 function setContext(key, value) {
-  client == null ? void 0 : client.setContext(key, value);
+  var _a;
+  (_a = readClient()) == null ? void 0 : _a.setContext(key, value);
 }
 function addBreadcrumb(crumb) {
-  client == null ? void 0 : client.addBreadcrumb(crumb);
+  var _a;
+  (_a = readClient()) == null ? void 0 : _a.addBreadcrumb(crumb);
 }
 function recordMetric(metric) {
-  client == null ? void 0 : client.recordMetric(metric);
+  var _a;
+  (_a = readClient()) == null ? void 0 : _a.recordMetric(metric);
 }
 async function flush() {
-  await (client == null ? void 0 : client.flush());
+  var _a;
+  await ((_a = readClient()) == null ? void 0 : _a.flush());
 }
 function close() {
-  client == null ? void 0 : client.close();
-  client = null;
+  var _a;
+  (_a = readClient()) == null ? void 0 : _a.close();
+  writeClient(null);
 }
 var Bugban = {
   VERSION: SDK_VERSION,