@squasher-ai/browser-logger 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Squasher
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,12 @@
+# @squasher-ai/browser-logger
+
+Squasher browser console transport
+
+## Install
+
+```bash
+npm install @squasher-ai/browser-logger
+```
+
+Docs: https://docs.squasher.ai/sdks/browser-logger
+Homepage: https://squasher.ai

package/dist/browser-logger.d.ts

@@ -0,0 +1,13 @@
+import type { BrowserLoggerConfig } from "./types";
+export declare class BrowserLogger {
+    private readonly config;
+    private readonly transport;
+    private readonly originalConsoleError;
+    private installed;
+    constructor(config: BrowserLoggerConfig);
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    private installConsoleErrorCapture;
+    private restoreConsoleErrorCapture;
+}
+//# sourceMappingURL=browser-logger.d.ts.map

package/dist/browser-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-logger.d.ts","sourceRoot":"","sources":["../src/browser-logger.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAWnD,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IACnD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAuB;IAC5D,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,mBAAmB;IAkBjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B,OAAO,CAAC,0BAA0B;IAelC,OAAO,CAAC,0BAA0B;CAQnC"}

package/dist/browser-logger.js

@@ -0,0 +1,56 @@
+import { buildConsoleEvent } from "./serializer";
+import { BrowserLoggerTransport } from "./transport";
+const DEFAULT_ENDPOINT = "https://ingest.squasher.ai";
+export class BrowserLogger {
+    config;
+    transport;
+    originalConsoleError;
+    installed = false;
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error("Squasher Browser Logger: apiKey is required");
+        }
+        if (!config.projectId) {
+            throw new Error("Squasher Browser Logger: projectId is required");
+        }
+        this.config = resolveConfig(config);
+        this.transport = new BrowserLoggerTransport(this.config);
+        this.originalConsoleError = console.error;
+        if (this.config.captureConsoleErrors) {
+            this.installConsoleErrorCapture();
+        }
+    }
+    async flush() {
+        await this.transport.flush();
+    }
+    async close() {
+        this.restoreConsoleErrorCapture();
+        await this.transport.close();
+    }
+    installConsoleErrorCapture() {
+        if (this.installed) {
+            return;
+        }
+        const originalConsoleError = this.originalConsoleError;
+        console.error = (...args) => {
+            Reflect.apply(originalConsoleError, console, args);
+            this.transport.enqueue(buildConsoleEvent(args, "error"));
+        };
+        this.installed = true;
+    }
+    restoreConsoleErrorCapture() {
+        if (!this.installed) {
+            return;
+        }
+        console.error = this.originalConsoleError;
+        this.installed = false;
+    }
+}
+function resolveConfig(config) {
+    return {
+        apiKey: config.apiKey,
+        projectId: config.projectId,
+        endpoint: config.endpoint ?? DEFAULT_ENDPOINT,
+        captureConsoleErrors: config.captureConsoleErrors ?? true,
+    };
+}

package/dist/browser-logger.umd.js

@@ -0,0 +1,420 @@
+(() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __moduleCache = /* @__PURE__ */ new WeakMap;
+  var __toCommonJS = (from) => {
+    var entry = __moduleCache.get(from), desc;
+    if (entry)
+      return entry;
+    entry = __defProp({}, "__esModule", { value: true });
+    if (from && typeof from === "object" || typeof from === "function")
+      __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+        get: () => from[key],
+        enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+      }));
+    __moduleCache.set(from, entry);
+    return entry;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, {
+        get: all[name],
+        enumerable: true,
+        configurable: true,
+        set: (newValue) => all[name] = () => newValue
+      });
+  };
+
+  // src/global.ts
+  var exports_global = {};
+  __export(exports_global, {
+    initBrowserLogger: () => initBrowserLogger,
+    getBrowserLogger: () => getBrowserLogger,
+    flushBrowserLogger: () => flushBrowserLogger,
+    default: () => global_default,
+    closeBrowserLogger: () => closeBrowserLogger,
+    BrowserLogger: () => BrowserLogger
+  });
+
+  // src/serializer.ts
+  var SDK_NAME = "@squasher-ai/browser-logger";
+  var SDK_VERSION = "0.1.0";
+  function buildConsoleEvent(args, level) {
+    const error = findError(args);
+    const pageUrl = getPageUrl();
+    const userAgent = getUserAgent();
+    const extra = {
+      console_arguments: Array.from(args, (arg) => toJsonValue(arg)),
+      console_method: level === "warning" ? "warn" : "error"
+    };
+    if (pageUrl) {
+      extra.page_url = pageUrl;
+    }
+    if (userAgent) {
+      extra.user_agent = userAgent;
+    }
+    return {
+      message: buildMessage(args, error),
+      type: error?.name,
+      stack: error?.stack,
+      level,
+      request: pageUrl ? { url: pageUrl } : undefined,
+      sdk: {
+        name: SDK_NAME,
+        version: SDK_VERSION
+      },
+      timestamp: new Date().toISOString(),
+      extra
+    };
+  }
+  function buildMessage(args, error) {
+    if (args.length === 0) {
+      return "console.error";
+    }
+    const parts = Array.from(args, (arg) => formatMessagePart(arg)).filter((part) => part.length > 0);
+    if (parts.length > 0) {
+      return parts.join(" ");
+    }
+    if (error?.message) {
+      return error.message;
+    }
+    return "console.error";
+  }
+  function formatMessagePart(value) {
+    if (value instanceof Error) {
+      return value.message || value.name || "Error";
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol") {
+      return String(value);
+    }
+    if (value === null) {
+      return "null";
+    }
+    if (typeof value === "undefined") {
+      return "undefined";
+    }
+    return stringifyJsonValue(toJsonValue(value));
+  }
+  function findError(args) {
+    return Array.from(args).find((arg) => arg instanceof Error);
+  }
+  function getPageUrl() {
+    if (typeof location === "undefined") {
+      return;
+    }
+    return location.href;
+  }
+  function getUserAgent() {
+    if (typeof navigator === "undefined") {
+      return;
+    }
+    return navigator.userAgent;
+  }
+  function stringifyJsonValue(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value);
+  }
+  function toJsonValue(value) {
+    if (value === null) {
+      return null;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      return value;
+    }
+    if (typeof value === "bigint" || typeof value === "symbol") {
+      return String(value);
+    }
+    if (typeof value === "undefined") {
+      return "undefined";
+    }
+    if (typeof value === "function") {
+      return `[Function ${value.name || "anonymous"}]`;
+    }
+    if (value instanceof Error) {
+      const serializedError = {
+        name: value.name,
+        message: value.message
+      };
+      if (value.stack) {
+        serializedError.stack = value.stack;
+      }
+      return serializedError;
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => toJsonValue(item));
+    }
+    return serializeObject(value);
+  }
+  function serializeObject(value) {
+    const seen = new WeakSet;
+    const json = JSON.stringify(value, (_key, nestedValue) => {
+      if (typeof nestedValue === "bigint" || typeof nestedValue === "symbol") {
+        return String(nestedValue);
+      }
+      if (typeof nestedValue === "function") {
+        return `[Function ${nestedValue.name || "anonymous"}]`;
+      }
+      if (nestedValue instanceof Error) {
+        const serializedError = {
+          name: nestedValue.name,
+          message: nestedValue.message
+        };
+        if (nestedValue.stack) {
+          serializedError.stack = nestedValue.stack;
+        }
+        return serializedError;
+      }
+      if (typeof nestedValue === "object" && nestedValue !== null) {
+        if (seen.has(nestedValue)) {
+          return "[Circular]";
+        }
+        seen.add(nestedValue);
+      }
+      return nestedValue;
+    });
+    if (!json) {
+      return String(value);
+    }
+    return JSON.parse(json);
+  }
+
+  // src/transport.ts
+  var DEFAULT_ENDPOINT = "https://ingest.squasher.ai";
+  var DEFAULT_BATCH_SIZE = 10;
+  var DEFAULT_FLUSH_INTERVAL_MS = 5000;
+
+  class BrowserLoggerTransport {
+    apiKey;
+    projectId;
+    endpoint;
+    queue = [];
+    flushTimer = null;
+    closed = false;
+    handlePageHide = () => {
+      this.flushOnPageHide();
+    };
+    handleVisibilityChange = () => {
+      if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+        this.flushOnPageHide();
+      }
+    };
+    constructor(config) {
+      this.apiKey = config.apiKey;
+      this.projectId = config.projectId;
+      this.endpoint = normalizeEndpoint(config.endpoint ?? DEFAULT_ENDPOINT);
+      this.flushTimer = setInterval(() => {
+        this.flush();
+      }, DEFAULT_FLUSH_INTERVAL_MS);
+      this.installListeners();
+    }
+    enqueue(event) {
+      if (this.closed) {
+        return;
+      }
+      this.queue.push(event);
+      if (this.queue.length >= DEFAULT_BATCH_SIZE) {
+        this.flush();
+      }
+    }
+    async flush() {
+      if (this.closed || this.queue.length === 0) {
+        return;
+      }
+      const events = this.queue.splice(0);
+      const body = stringifyPayload(events);
+      const success = await this.sendFetch(body);
+      if (!success) {
+        this.queue.unshift(...events);
+      }
+    }
+    async close() {
+      if (this.closed) {
+        return;
+      }
+      this.removeListeners();
+      if (this.flushTimer) {
+        clearInterval(this.flushTimer);
+        this.flushTimer = null;
+      }
+      await this.flush();
+      this.closed = true;
+    }
+    flushOnPageHide() {
+      if (this.closed || this.queue.length === 0) {
+        return;
+      }
+      const events = this.queue.splice(0);
+      const body = stringifyPayload(events);
+      if (this.trySendBeacon(body)) {
+        return;
+      }
+      this.sendFetch(body).then((success) => {
+        if (!success) {
+          this.queue.unshift(...events);
+        }
+      });
+    }
+    installListeners() {
+      if (typeof document !== "undefined") {
+        document.addEventListener("visibilitychange", this.handleVisibilityChange);
+      }
+      if (typeof window !== "undefined") {
+        window.addEventListener("pagehide", this.handlePageHide);
+        window.addEventListener("beforeunload", this.handlePageHide);
+      }
+    }
+    removeListeners() {
+      if (typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", this.handleVisibilityChange);
+      }
+      if (typeof window !== "undefined") {
+        window.removeEventListener("pagehide", this.handlePageHide);
+        window.removeEventListener("beforeunload", this.handlePageHide);
+      }
+    }
+    trySendBeacon(body) {
+      if (typeof navigator === "undefined" || typeof navigator.sendBeacon !== "function") {
+        return false;
+      }
+      try {
+        const blob = new Blob([body], { type: "application/json" });
+        return navigator.sendBeacon(this.getBeaconUrl(), blob);
+      } catch {
+        return false;
+      }
+    }
+    async sendFetch(body) {
+      try {
+        const response = await fetch(this.getIngestUrl(), {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-squasher-key": this.apiKey
+          },
+          body,
+          keepalive: true
+        });
+        return response.ok;
+      } catch {
+        return false;
+      }
+    }
+    getIngestUrl() {
+      return `${this.endpoint}/v1/ingest/${this.projectId}`;
+    }
+    getBeaconUrl() {
+      return `${this.getIngestUrl()}?key=${encodeURIComponent(this.apiKey)}`;
+    }
+  }
+  function normalizeEndpoint(endpoint) {
+    return endpoint.replace(/\/+$/, "");
+  }
+  function stringifyPayload(events) {
+    const payload = { events };
+    return JSON.stringify(payload);
+  }
+
+  // src/browser-logger.ts
+  var DEFAULT_ENDPOINT2 = "https://ingest.squasher.ai";
+
+  class BrowserLogger {
+    config;
+    transport;
+    originalConsoleError;
+    installed = false;
+    constructor(config) {
+      if (!config.apiKey) {
+        throw new Error("Squasher Browser Logger: apiKey is required");
+      }
+      if (!config.projectId) {
+        throw new Error("Squasher Browser Logger: projectId is required");
+      }
+      this.config = resolveConfig(config);
+      this.transport = new BrowserLoggerTransport(this.config);
+      this.originalConsoleError = console.error;
+      if (this.config.captureConsoleErrors) {
+        this.installConsoleErrorCapture();
+      }
+    }
+    async flush() {
+      await this.transport.flush();
+    }
+    async close() {
+      this.restoreConsoleErrorCapture();
+      await this.transport.close();
+    }
+    installConsoleErrorCapture() {
+      if (this.installed) {
+        return;
+      }
+      const originalConsoleError = this.originalConsoleError;
+      console.error = (...args) => {
+        Reflect.apply(originalConsoleError, console, args);
+        this.transport.enqueue(buildConsoleEvent(args, "error"));
+      };
+      this.installed = true;
+    }
+    restoreConsoleErrorCapture() {
+      if (!this.installed) {
+        return;
+      }
+      console.error = this.originalConsoleError;
+      this.installed = false;
+    }
+  }
+  function resolveConfig(config) {
+    return {
+      apiKey: config.apiKey,
+      projectId: config.projectId,
+      endpoint: config.endpoint ?? DEFAULT_ENDPOINT2,
+      captureConsoleErrors: config.captureConsoleErrors ?? true
+    };
+  }
+  // src/index.ts
+  var browserLogger = null;
+  function initBrowserLogger(config) {
+    if (browserLogger) {
+      throw new Error("Squasher Browser Logger already initialized. Call close() first.");
+    }
+    browserLogger = new BrowserLogger(config);
+    return browserLogger;
+  }
+  function getBrowserLogger() {
+    if (!browserLogger) {
+      throw new Error("Squasher Browser Logger is not initialized. Call init() first.");
+    }
+    return browserLogger;
+  }
+  async function flushBrowserLogger() {
+    await getBrowserLogger().flush();
+  }
+  async function closeBrowserLogger() {
+    if (!browserLogger) {
+      return;
+    }
+    const activeLogger = browserLogger;
+    browserLogger = null;
+    await activeLogger.close();
+  }
+
+  // src/global.ts
+  var browserLoggerGlobal = {
+    BrowserLogger,
+    close: closeBrowserLogger,
+    closeBrowserLogger,
+    flush: flushBrowserLogger,
+    flushBrowserLogger,
+    getBrowserLogger,
+    init: initBrowserLogger,
+    initBrowserLogger
+  };
+  globalThis.SquasherBrowserLogger = browserLoggerGlobal;
+  var global_default = browserLoggerGlobal;
+})();

package/dist/global.d.ts

@@ -0,0 +1,14 @@
+import { BrowserLogger, closeBrowserLogger, flushBrowserLogger, getBrowserLogger, initBrowserLogger } from "./index";
+declare const browserLoggerGlobal: {
+    BrowserLogger: typeof BrowserLogger;
+    close: typeof closeBrowserLogger;
+    closeBrowserLogger: typeof closeBrowserLogger;
+    flush: typeof flushBrowserLogger;
+    flushBrowserLogger: typeof flushBrowserLogger;
+    getBrowserLogger: typeof getBrowserLogger;
+    init: typeof initBrowserLogger;
+    initBrowserLogger: typeof initBrowserLogger;
+};
+export default browserLoggerGlobal;
+export { BrowserLogger, closeBrowserLogger, flushBrowserLogger, getBrowserLogger, initBrowserLogger, };
+//# sourceMappingURL=global.d.ts.map

package/dist/global.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAEjB,QAAA,MAAM,mBAAmB;;;;;;;;;CASxB,CAAC;AAQF,eAAe,mBAAmB,CAAC;AACnC,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,GAClB,CAAC"}

package/dist/global.js

@@ -0,0 +1,14 @@
+import { BrowserLogger, closeBrowserLogger, flushBrowserLogger, getBrowserLogger, initBrowserLogger, } from "./index";
+const browserLoggerGlobal = {
+    BrowserLogger,
+    close: closeBrowserLogger,
+    closeBrowserLogger,
+    flush: flushBrowserLogger,
+    flushBrowserLogger,
+    getBrowserLogger,
+    init: initBrowserLogger,
+    initBrowserLogger,
+};
+globalThis.SquasherBrowserLogger = browserLoggerGlobal;
+export default browserLoggerGlobal;
+export { BrowserLogger, closeBrowserLogger, flushBrowserLogger, getBrowserLogger, initBrowserLogger, };

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { BrowserLogger } from "./browser-logger";
+export type { BrowserLoggerConfig, BrowserLoggerEvent, IngestBatchPayload, JsonArray, JsonObject, JsonValue, Level, } from "./types";
+import { BrowserLogger } from "./browser-logger";
+import type { BrowserLoggerConfig } from "./types";
+export declare function initBrowserLogger(config: BrowserLoggerConfig): BrowserLogger;
+export declare function getBrowserLogger(): BrowserLogger;
+export declare function flushBrowserLogger(): Promise<void>;
+export declare function closeBrowserLogger(): Promise<void>;
+export { closeBrowserLogger as close, flushBrowserLogger as flush, initBrowserLogger as init };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,YAAY,EACV,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,SAAS,EACT,UAAU,EACV,SAAS,EACT,KAAK,GACN,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAInD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,GAAG,aAAa,CAO5E;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAMhD;AAED,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAExD;AAED,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAQxD;AAED,OAAO,EAAE,kBAAkB,IAAI,KAAK,EAAE,kBAAkB,IAAI,KAAK,EAAE,iBAAiB,IAAI,IAAI,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,28 @@
+export { BrowserLogger } from "./browser-logger";
+import { BrowserLogger } from "./browser-logger";
+let browserLogger = null;
+export function initBrowserLogger(config) {
+    if (browserLogger) {
+        throw new Error("Squasher Browser Logger already initialized. Call close() first.");
+    }
+    browserLogger = new BrowserLogger(config);
+    return browserLogger;
+}
+export function getBrowserLogger() {
+    if (!browserLogger) {
+        throw new Error("Squasher Browser Logger is not initialized. Call init() first.");
+    }
+    return browserLogger;
+}
+export async function flushBrowserLogger() {
+    await getBrowserLogger().flush();
+}
+export async function closeBrowserLogger() {
+    if (!browserLogger) {
+        return;
+    }
+    const activeLogger = browserLogger;
+    browserLogger = null;
+    await activeLogger.close();
+}
+export { closeBrowserLogger as close, flushBrowserLogger as flush, initBrowserLogger as init };

package/dist/serializer.d.ts

@@ -0,0 +1,5 @@
+import type { BrowserLoggerEvent, Level } from "./types";
+type ConsoleArgs = Parameters<typeof console.error>;
+export declare function buildConsoleEvent(args: ConsoleArgs, level: Level): BrowserLoggerEvent;
+export {};
+//# sourceMappingURL=serializer.d.ts.map

package/dist/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../src/serializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAyB,KAAK,EAAE,MAAM,SAAS,CAAC;AAKhF,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;AAGpD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,GAAG,kBAAkB,CA+BrF"}

package/dist/serializer.js

@@ -0,0 +1,148 @@
+const SDK_NAME = "@squasher-ai/browser-logger";
+const SDK_VERSION = "0.1.0";
+export function buildConsoleEvent(args, level) {
+    const error = findError(args);
+    const pageUrl = getPageUrl();
+    const userAgent = getUserAgent();
+    const extra = {
+        console_arguments: Array.from(args, (arg) => toJsonValue(arg)),
+        console_method: level === "warning" ? "warn" : "error",
+    };
+    if (pageUrl) {
+        extra.page_url = pageUrl;
+    }
+    if (userAgent) {
+        extra.user_agent = userAgent;
+    }
+    return {
+        message: buildMessage(args, error),
+        type: error?.name,
+        stack: error?.stack,
+        level,
+        request: pageUrl ? { url: pageUrl } : undefined,
+        sdk: {
+            name: SDK_NAME,
+            version: SDK_VERSION,
+        },
+        timestamp: new Date().toISOString(),
+        extra,
+    };
+}
+function buildMessage(args, error) {
+    if (args.length === 0) {
+        return "console.error";
+    }
+    const parts = Array.from(args, (arg) => formatMessagePart(arg)).filter((part) => part.length > 0);
+    if (parts.length > 0) {
+        return parts.join(" ");
+    }
+    if (error?.message) {
+        return error.message;
+    }
+    return "console.error";
+}
+function formatMessagePart(value) {
+    if (value instanceof Error) {
+        return value.message || value.name || "Error";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "bigint" ||
+        typeof value === "symbol") {
+        return String(value);
+    }
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "undefined") {
+        return "undefined";
+    }
+    return stringifyJsonValue(toJsonValue(value));
+}
+function findError(args) {
+    return Array.from(args).find((arg) => arg instanceof Error);
+}
+function getPageUrl() {
+    if (typeof location === "undefined") {
+        return undefined;
+    }
+    return location.href;
+}
+function getUserAgent() {
+    if (typeof navigator === "undefined") {
+        return undefined;
+    }
+    return navigator.userAgent;
+}
+function stringifyJsonValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+function toJsonValue(value) {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "bigint" || typeof value === "symbol") {
+        return String(value);
+    }
+    if (typeof value === "undefined") {
+        return "undefined";
+    }
+    if (typeof value === "function") {
+        return `[Function ${value.name || "anonymous"}]`;
+    }
+    if (value instanceof Error) {
+        const serializedError = {
+            name: value.name,
+            message: value.message,
+        };
+        if (value.stack) {
+            serializedError.stack = value.stack;
+        }
+        return serializedError;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => toJsonValue(item));
+    }
+    return serializeObject(value);
+}
+function serializeObject(value) {
+    const seen = new WeakSet();
+    const json = JSON.stringify(value, (_key, nestedValue) => {
+        if (typeof nestedValue === "bigint" || typeof nestedValue === "symbol") {
+            return String(nestedValue);
+        }
+        if (typeof nestedValue === "function") {
+            return `[Function ${nestedValue.name || "anonymous"}]`;
+        }
+        if (nestedValue instanceof Error) {
+            const serializedError = {
+                name: nestedValue.name,
+                message: nestedValue.message,
+            };
+            if (nestedValue.stack) {
+                serializedError.stack = nestedValue.stack;
+            }
+            return serializedError;
+        }
+        if (typeof nestedValue === "object" && nestedValue !== null) {
+            if (seen.has(nestedValue)) {
+                return "[Circular]";
+            }
+            seen.add(nestedValue);
+        }
+        return nestedValue;
+    });
+    if (!json) {
+        return String(value);
+    }
+    return JSON.parse(json);
+}

package/dist/transport.d.ts

@@ -0,0 +1,28 @@
+import type { BrowserLoggerEvent } from "./types";
+export interface BrowserLoggerTransportConfig {
+    apiKey: string;
+    projectId: string;
+    endpoint?: string;
+}
+export declare class BrowserLoggerTransport {
+    private readonly apiKey;
+    private readonly projectId;
+    private readonly endpoint;
+    private readonly queue;
+    private flushTimer;
+    private closed;
+    private readonly handlePageHide;
+    private readonly handleVisibilityChange;
+    constructor(config: BrowserLoggerTransportConfig);
+    enqueue(event: BrowserLoggerEvent): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    private flushOnPageHide;
+    private installListeners;
+    private removeListeners;
+    private trySendBeacon;
+    private sendFetch;
+    private getIngestUrl;
+    private getBeaconUrl;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAsB,MAAM,SAAS,CAAC;AAMtE,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4B;IAClD,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAE7B;IAEF,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAIrC;gBAEU,MAAM,EAAE,4BAA4B;IAYhD,OAAO,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAWlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IActB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB5B,OAAO,CAAC,eAAe;IAmBvB,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,aAAa;YAaP,SAAS;IAkBvB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,YAAY;CAGrB"}

package/dist/transport.js

@@ -0,0 +1,135 @@
+const DEFAULT_ENDPOINT = "https://ingest.squasher.ai";
+const DEFAULT_BATCH_SIZE = 10;
+const DEFAULT_FLUSH_INTERVAL_MS = 5_000;
+export class BrowserLoggerTransport {
+    apiKey;
+    projectId;
+    endpoint;
+    queue = [];
+    flushTimer = null;
+    closed = false;
+    handlePageHide = () => {
+        this.flushOnPageHide();
+    };
+    handleVisibilityChange = () => {
+        if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+            this.flushOnPageHide();
+        }
+    };
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.projectId = config.projectId;
+        this.endpoint = normalizeEndpoint(config.endpoint ?? DEFAULT_ENDPOINT);
+        this.flushTimer = setInterval(() => {
+            void this.flush();
+        }, DEFAULT_FLUSH_INTERVAL_MS);
+        this.installListeners();
+    }
+    enqueue(event) {
+        if (this.closed) {
+            return;
+        }
+        this.queue.push(event);
+        if (this.queue.length >= DEFAULT_BATCH_SIZE) {
+            void this.flush();
+        }
+    }
+    async flush() {
+        if (this.closed || this.queue.length === 0) {
+            return;
+        }
+        const events = this.queue.splice(0);
+        const body = stringifyPayload(events);
+        const success = await this.sendFetch(body);
+        if (!success) {
+            this.queue.unshift(...events);
+        }
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.removeListeners();
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.flush();
+        this.closed = true;
+    }
+    flushOnPageHide() {
+        if (this.closed || this.queue.length === 0) {
+            return;
+        }
+        const events = this.queue.splice(0);
+        const body = stringifyPayload(events);
+        if (this.trySendBeacon(body)) {
+            return;
+        }
+        void this.sendFetch(body).then((success) => {
+            if (!success) {
+                this.queue.unshift(...events);
+            }
+        });
+    }
+    installListeners() {
+        if (typeof document !== "undefined") {
+            document.addEventListener("visibilitychange", this.handleVisibilityChange);
+        }
+        if (typeof window !== "undefined") {
+            window.addEventListener("pagehide", this.handlePageHide);
+            window.addEventListener("beforeunload", this.handlePageHide);
+        }
+    }
+    removeListeners() {
+        if (typeof document !== "undefined") {
+            document.removeEventListener("visibilitychange", this.handleVisibilityChange);
+        }
+        if (typeof window !== "undefined") {
+            window.removeEventListener("pagehide", this.handlePageHide);
+            window.removeEventListener("beforeunload", this.handlePageHide);
+        }
+    }
+    trySendBeacon(body) {
+        if (typeof navigator === "undefined" || typeof navigator.sendBeacon !== "function") {
+            return false;
+        }
+        try {
+            const blob = new Blob([body], { type: "application/json" });
+            return navigator.sendBeacon(this.getBeaconUrl(), blob);
+        }
+        catch {
+            return false;
+        }
+    }
+    async sendFetch(body) {
+        try {
+            const response = await fetch(this.getIngestUrl(), {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-squasher-key": this.apiKey,
+                },
+                body,
+                keepalive: true,
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    getIngestUrl() {
+        return `${this.endpoint}/v1/ingest/${this.projectId}`;
+    }
+    getBeaconUrl() {
+        return `${this.getIngestUrl()}?key=${encodeURIComponent(this.apiKey)}`;
+    }
+}
+function normalizeEndpoint(endpoint) {
+    return endpoint.replace(/\/+$/, "");
+}
+function stringifyPayload(events) {
+    const payload = { events };
+    return JSON.stringify(payload);
+}

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+export interface BrowserLoggerConfig {
+    apiKey: string;
+    projectId: string;
+    endpoint?: string;
+    captureConsoleErrors?: boolean;
+}
+export type Level = "error" | "warning";
+export type JsonPrimitive = string | number | boolean | null;
+export interface JsonArray extends Array<JsonValue> {
+}
+export interface JsonObject {
+    [key: string]: JsonValue | undefined;
+}
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+export interface BrowserLoggerEvent {
+    message: string;
+    type?: string;
+    stack?: string;
+    level: Level;
+    request?: {
+        url?: string;
+    };
+    sdk: {
+        name: string;
+        version: string;
+    };
+    timestamp: string;
+    extra?: JsonObject;
+}
+export interface IngestBatchPayload {
+    events: BrowserLoggerEvent[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,SAAS,CAAC;AAExC,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAE7D,MAAM,WAAW,SAAU,SAAQ,KAAK,CAAC,SAAS,CAAC;CAAG;AAEtD,MAAM,WAAW,UAAU;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;CACtC;AAED,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,UAAU,GAAG,SAAS,CAAC;AAE/D,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,CAAC,EAAE;QACR,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;IACF,GAAG,EAAE;QACH,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,kBAAkB,EAAE,CAAC;CAC9B"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@squasher-ai/browser-logger",
+  "version": "0.1.0",
+  "description": "Squasher browser console transport",
+  "homepage": "https://squasher.ai",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/squasher-ai/squasher.git",
+    "directory": "packages/browser-logger"
+  },
+  "bugs": {
+    "url": "https://github.com/squasher-ai/squasher/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "keywords": [
+    "squasher",
+    "browser",
+    "logger",
+    "console",
+    "transport",
+    "error-monitoring"
+  ]
+}