@atsail/browser 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { EventLevel, InitOptions } from "./types";
+export declare function init(options: InitOptions): void;
+export declare function captureException(error: unknown, context?: Record<string, unknown>): void;
+export declare function captureMessage(message: string, level?: EventLevel, context?: Record<string, unknown>): void;
+export declare function flush(): void;
+export type { AtsailEvent, EventLevel, InitOptions } from "./types";

package/dist/index.js

@@ -0,0 +1,174 @@
+// src/transport.ts
+var DEFAULT_ENDPOINT = "https://api.atsail.io/events";
+var DEFAULT_FLUSH_INTERVAL_MS = 5000;
+var DEFAULT_MAX_BATCH_SIZE = 20;
+
+class Transport {
+  publishableKey;
+  endpoint;
+  flushIntervalMs;
+  maxBatchSize;
+  queue = [];
+  timer = null;
+  constructor(publishableKey, endpoint = DEFAULT_ENDPOINT, flushIntervalMs = DEFAULT_FLUSH_INTERVAL_MS, maxBatchSize = DEFAULT_MAX_BATCH_SIZE) {
+    this.publishableKey = publishableKey;
+    this.endpoint = endpoint;
+    this.flushIntervalMs = flushIntervalMs;
+    this.maxBatchSize = maxBatchSize;
+    this.timer = setInterval(() => this.flush(), this.flushIntervalMs);
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden")
+        this.flush(true);
+    });
+    window.addEventListener("pagehide", () => this.flush(true));
+  }
+  enqueue(event) {
+    this.queue.push(event);
+    if (this.queue.length >= this.maxBatchSize)
+      this.flush();
+  }
+  flush(useBeacon = false) {
+    if (this.queue.length === 0)
+      return;
+    const events = this.queue;
+    this.queue = [];
+    const body = JSON.stringify({ publishableKey: this.publishableKey, events });
+    if (useBeacon && navigator.sendBeacon) {
+      const blob = new Blob([body], { type: "application/json" });
+      navigator.sendBeacon(this.endpoint, blob);
+      return;
+    }
+    fetch(this.endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      keepalive: true
+    }).catch(() => {
+      return;
+    });
+  }
+  destroy() {
+    if (this.timer)
+      clearInterval(this.timer);
+    this.flush(true);
+  }
+}
+
+// src/instrumentation.ts
+function installGlobalHandlers(emit) {
+  window.addEventListener("error", (e) => {
+    emit({
+      type: "exception",
+      message: e.message,
+      stack: e.error?.stack,
+      source: e.filename,
+      line: e.lineno,
+      col: e.colno,
+      timestamp: Date.now()
+    });
+  });
+  window.addEventListener("unhandledrejection", (e) => {
+    const reason = e.reason;
+    emit({
+      type: "unhandledrejection",
+      message: reason instanceof Error ? reason.message : String(reason),
+      stack: reason instanceof Error ? reason.stack : undefined,
+      timestamp: Date.now()
+    });
+  });
+}
+function installFetchInterceptor(emit) {
+  const originalFetch = window.fetch;
+  if (!originalFetch)
+    return;
+  const patchedFetch = async (...args) => {
+    const [input, init] = args;
+    const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+    const url = input instanceof Request ? input.url : String(input);
+    const response = await originalFetch(...args);
+    if (response.status >= 400) {
+      emit({
+        type: "network_error",
+        url,
+        method,
+        status: response.status,
+        statusText: response.statusText,
+        timestamp: Date.now()
+      });
+    }
+    return response;
+  };
+  window.fetch = Object.assign(patchedFetch, originalFetch);
+}
+function installXhrInterceptor(emit) {
+  const OriginalXhr = window.XMLHttpRequest;
+  if (!OriginalXhr)
+    return;
+  const originalOpen = OriginalXhr.prototype.open;
+  const originalSend = OriginalXhr.prototype.send;
+  OriginalXhr.prototype.open = function(method, url, ...rest) {
+    this.__atsailMethod = method;
+    this.__atsailUrl = String(url);
+    return originalOpen.call(this, method, url, ...rest);
+  };
+  OriginalXhr.prototype.send = function(...args) {
+    this.addEventListener("loadend", () => {
+      if (this.status >= 400) {
+        emit({
+          type: "network_error",
+          url: this.__atsailUrl ?? "",
+          method: this.__atsailMethod ?? "GET",
+          status: this.status,
+          statusText: this.statusText,
+          timestamp: Date.now()
+        });
+      }
+    });
+    return originalSend.call(this, ...args);
+  };
+}
+
+// src/index.ts
+var transport = null;
+function init(options) {
+  if (transport)
+    return;
+  if (typeof window === "undefined")
+    return;
+  transport = new Transport(options.publishableKey, options.endpoint, options.flushIntervalMs, options.maxBatchSize);
+  const emit = transport.enqueue.bind(transport);
+  installGlobalHandlers(emit);
+  installFetchInterceptor(emit);
+  installXhrInterceptor(emit);
+}
+function captureException(error, context) {
+  if (!transport)
+    return;
+  transport.enqueue({
+    type: "exception",
+    message: error instanceof Error ? error.message : String(error),
+    stack: error instanceof Error ? error.stack : undefined,
+    context,
+    timestamp: Date.now()
+  });
+}
+function captureMessage(message, level = "info", context) {
+  if (!transport)
+    return;
+  transport.enqueue({
+    type: "message",
+    message,
+    level,
+    context,
+    timestamp: Date.now()
+  });
+}
+function flush() {
+  transport?.flush();
+}
+export {
+  init,
+  flush,
+  captureMessage,
+  captureException
+};

package/dist/instrumentation.d.ts

@@ -0,0 +1,6 @@
+import type { AtsailEvent } from "./types";
+type Emit = (event: AtsailEvent) => void;
+export declare function installGlobalHandlers(emit: Emit): void;
+export declare function installFetchInterceptor(emit: Emit): void;
+export declare function installXhrInterceptor(emit: Emit): void;
+export {};

package/dist/transport.d.ts

@@ -0,0 +1,13 @@
+import type { AtsailEvent } from "./types";
+export declare class Transport {
+    private readonly publishableKey;
+    private readonly endpoint;
+    private readonly flushIntervalMs;
+    private readonly maxBatchSize;
+    private queue;
+    private timer;
+    constructor(publishableKey: string, endpoint?: string, flushIntervalMs?: number, maxBatchSize?: number);
+    enqueue(event: AtsailEvent): void;
+    flush(useBeacon?: boolean): void;
+    destroy(): void;
+}

package/dist/types.d.ts

@@ -0,0 +1,36 @@
+export type EventLevel = "info" | "warning" | "error";
+export type AtsailEvent = {
+    type: "exception";
+    message: string;
+    stack?: string;
+    source?: string;
+    line?: number;
+    col?: number;
+    context?: Record<string, unknown>;
+    timestamp: number;
+} | {
+    type: "unhandledrejection";
+    message: string;
+    stack?: string;
+    context?: Record<string, unknown>;
+    timestamp: number;
+} | {
+    type: "network_error";
+    url: string;
+    method: string;
+    status: number;
+    statusText?: string;
+    timestamp: number;
+} | {
+    type: "message";
+    message: string;
+    level: EventLevel;
+    context?: Record<string, unknown>;
+    timestamp: number;
+};
+export type InitOptions = {
+    publishableKey: string;
+    endpoint?: string;
+    flushIntervalMs?: number;
+    maxBatchSize?: number;
+};

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@atsail/browser",
+  "version": "0.1.0",
+  "description": "AtSail browser SDK",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target browser --format esm && tsc --emitDeclarationOnly --declaration --outDir dist",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/bun": "latest"
+  }
+}