@pluve/logger-sdk 0.0.1

package/README.md

@@ -0,0 +1,108 @@
+# @pluve/logger-sdk 使用说明
+
+## 简介
+- 统一的前端日志采集 SDK，支持 H5 与微信小程序。
+- 能力包括：批量上报、分级路由（`info|warn|error`）、自动 PV/错误/性能采集、本地持久化与 IndexedDB 冗余、页面关闭时 `sendBeacon` 兜底。
+
+## 安装与引入
+- 安装：`pnpm add @pluve/logger-sdk`
+- ESM：`import LoggerSDK from '@pluve/logger-sdk'`
+- UMD：构建后全局为 `LoggerSDK`，示例：`const { LoggerSDK } = window.LoggerSDK`
+
+## 快速开始
+```ts
+import LoggerSDK from '@pluve/logger-sdk';
+
+const sdk = new LoggerSDK({
+  endpoints: {
+    default: '/api/collect',
+    info: '/api/collect/info',
+    warn: '/api/collect/warn',
+    error: '/api/collect/error',
+  },
+  appId: 'your-app',
+  debug: true,
+  enableAutoPV: true,
+  enablePerf: true,
+});
+
+sdk.track({ type: 'custom', level: 'info', ctx: { action: 'click_button' } });
+```
+
+## API
+- `new LoggerSDK(options)`
+- `track(event, headers?)`：事件入队并持久化，必要时触发批量上报。位置 `packages/logger-sdk/src/loggerSDK.ts:121`
+- `flush(extraHeaders?)`：按批量大小取队列，同批按 `level` 并行上报并重试。位置 `packages/logger-sdk/src/loggerSDK.ts:156-221`
+- `flushAll()`：非阻塞轮询清空队列，尊重并发锁。位置 `packages/logger-sdk/src/loggerSDK.ts:223-233`
+- `identify(user)`：设置应用/用户信息（如 `appId`）。位置 `packages/logger-sdk/src/loggerSDK.ts:222`
+- `setCommon(params)`：动态覆写通用配置（如 `globalHeaders`）。位置 `packages/logger-sdk/src/loggerSDK.ts:227`
+- `destroy()`：停止定时器并关闭。位置 `packages/logger-sdk/src/loggerSDK.ts:232`
+
+## 自动采集
+- 错误采集：JS 错误、未捕获 Promise、资源加载错误。位置 `packages/logger-sdk/src/loggerSDK.ts:238-275`
+- 自动 PV：拦截 `history.pushState/replaceState` 与 `popstate`，采集单页浏览。位置 `packages/logger-sdk/src/loggerSDK.ts:277-299`
+- 性能采集：Navigation Timing + Paint Entries。位置 `packages/logger-sdk/src/loggerSDK.ts:301-328`
+
+## 页面关闭兜底
+- 当页面隐藏或关闭时触发 `flushBeacon()`，使用 `navigator.sendBeacon` 尝试上报队列，不阻塞、不移除队列。
+- 监听位置：`packages/logger-sdk/src/loggerSDK.ts:270-293`
+- 方法位置：`packages/logger-sdk/src/loggerSDK.ts:333-350`
+- 传输适配器 Beacon 通道：`packages/logger-sdk/src/transportAdapter.ts:12-20`
+
+## 配置项（SDKOptions）
+```ts
+interface SDKOptions {
+  endpoints: Partial<Record<'info'|'warn'|'error'|'default', string>>;
+  appId?: string;
+  env?: 'h5' | 'wechat' | 'unknown';
+  batchSize?: number;           // 默认 10
+  flushInterval?: number;       // 默认 5000ms
+  retryCount?: number;          // 默认 3
+  retryBase?: number;           // 默认 300ms（指数退避基数）
+  storageKey?: string;          // 默认 'logger_sdk_cache_v2'
+  maxCacheSize?: number;        // 默认 2000
+  timeout?: number;             // 默认 10000ms
+  debug?: boolean;
+  transport?: (payload: any, opts?: SDKOptions & { endpoint?: string, headers?: Record<string,string> }) => Promise<void>;
+  globalHeaders?: Record<string,string>;
+  enableAutoPV?: boolean;       // 默认 true
+  enablePerf?: boolean;         // 默认 true
+  useBeacon?: boolean;          // 传输适配器识别 Beacon 的标志（SDK 内部在 flushBeacon 时传入）
+}
+```
+
+## 传输适配器
+- 默认选择：`sendBeacon`（兜底）→ 微信 `wx.request` → 浏览器 `fetch`。
+- 可自定义：实现 `transport(payload, opts)`，识别 `opts.useBeacon` 后走轻量通道。
+
+## 持久化与冗余
+- H5：`localStorage` + IndexedDB 冗余队列。初始化位置 `packages/logger-sdk/src/loggerSDK.ts:50-61`
+- 微信：`wx.*Storage`。实现位置 `packages/logger-sdk/src/storeAdapter.ts`
+
+## 最佳实践
+- 分级路由：至少提供 `default`，按需配置 `info|warn|error` 的独立地址。
+- 吞吐与可靠性：高频场景提高 `batchSize`（如 20–50），缩短 `flushInterval`（如 3000–5000ms）；弱网提高 `retryCount` 或 `retryBase`。
+- 统一头部：在 `globalHeaders` 添加溯源头（如 `x-trace-id`、`x-app-version`）。
+- 页面关闭兜底：无需手动调用，SDK 已自动在合适时机触发；若使用自定义 `transport`，注意识别 `useBeacon`。
+
+## 示例：自定义传输
+```ts
+const transport = async (payload: any, opts?: any) => {
+  const body = JSON.stringify(payload);
+  if (opts?.useBeacon && navigator.sendBeacon) {
+    navigator.sendBeacon(opts.endpoint || '', new Blob([body], { type: 'application/json' }));
+    return;
+  }
+  await fetch(opts?.endpoint || '', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...(opts?.globalHeaders || {}), ...(opts?.headers || {}) },
+    body,
+  });
+};
+
+const sdk = new LoggerSDK({ endpoints: { default: '/api/collect' }, transport });
+```
+
+## 调试
+- 开启 `debug: true` 查看控制台内部日志。
+- 生成 UMD Demo HTML：`LoggerSDK.generateDemoHtml()`（方法位置：`packages/logger-sdk/src/loggerSDK.ts:330-361`）。

package/dist/cjs/dbQueue.d.ts

@@ -0,0 +1,10 @@
+export default class IDBQueue {
+    private dbName;
+    private storeName;
+    private db;
+    constructor(dbName?: string, storeName?: string);
+    open(): Promise<void>;
+    add(item: any): Promise<void>;
+    getAll(): Promise<any[]>;
+    clear(): Promise<unknown>;
+}

package/dist/cjs/dbQueue.js

@@ -0,0 +1,88 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dbQueue.ts
+var dbQueue_exports = {};
+__export(dbQueue_exports, {
+  default: () => IDBQueue
+});
+module.exports = __toCommonJS(dbQueue_exports);
+var import_utils = require("./utils");
+var IDBQueue = class {
+  constructor(dbName = "logger_sdk_db", storeName = "queue") {
+    this.db = null;
+    this.dbName = dbName;
+    this.storeName = storeName;
+  }
+  // 打开数据库并初始化对象仓库
+  async open() {
+    if (!(0, import_utils.isBrowser)() || !(0, import_utils.isIndexedDBAvailable)())
+      return;
+    if (this.db)
+      return;
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(this.dbName, 1);
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        if (!db.objectStoreNames.contains(this.storeName))
+          db.createObjectStore(this.storeName, { autoIncrement: true });
+      };
+      req.onsuccess = () => {
+        this.db = req.result;
+        resolve();
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+  // 入队：追加一条记录
+  async add(item) {
+    if (!this.db)
+      return;
+    return new Promise((res, rej) => {
+      const tx = this.db.transaction(this.storeName, "readwrite");
+      const st = tx.objectStore(this.storeName);
+      const r = st.add(item);
+      r.onsuccess = () => res();
+      r.onerror = () => rej(r.error);
+    });
+  }
+  // 读取全部记录（调试/回溯用）
+  async getAll() {
+    if (!this.db)
+      return [];
+    return new Promise((res, rej) => {
+      const tx = this.db.transaction(this.storeName, "readonly");
+      const st = tx.objectStore(this.storeName);
+      const req = st.getAll();
+      req.onsuccess = () => res(req.result || []);
+      req.onerror = () => rej(req.error);
+    });
+  }
+  // 清空队列：发送成功后用于兜底清理
+  async clear() {
+    if (!this.db)
+      return;
+    return new Promise((res, rej) => {
+      const tx = this.db.transaction(this.storeName, "readwrite");
+      const st = tx.objectStore(this.storeName);
+      const req = st.clear();
+      req.onsuccess = () => res(void 0);
+      req.onerror = () => rej(req.error);
+    });
+  }
+};

package/dist/cjs/index.d.ts

@@ -0,0 +1 @@
+export { LoggerSDK } from './loggerSDK';

package/dist/cjs/index.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  LoggerSDK: () => import_loggerSDK.LoggerSDK
+});
+module.exports = __toCommonJS(src_exports);
+var import_loggerSDK = require("./loggerSDK");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoggerSDK
+});

package/dist/cjs/loggerSDK.d.ts

@@ -0,0 +1,29 @@
+import { LogEvent, SDKOptions } from './types';
+export declare class LoggerSDK {
+    private opts;
+    private env;
+    private inMemoryQueue;
+    private seq;
+    private timerId;
+    private storage;
+    private closed;
+    private idbQueue;
+    private flushing;
+    constructor(options: SDKOptions);
+    private logDebug;
+    private loadFromStorage;
+    private persistToStorage;
+    private startTimer;
+    private stopTimer;
+    track(event: Partial<LogEvent>, headers?: Record<string, string>): Promise<void>;
+    flush(extraHeaders?: Record<string, string>): Promise<void>;
+    flushAll(): Promise<void>;
+    identify(user: Record<string, any>): Promise<void>;
+    setCommon(params: Record<string, any>): Promise<void>;
+    destroy(): void;
+    private attachGlobalHandlers;
+    private installAutoPV;
+    private collectPerf;
+    private flushBeacon;
+}
+export default LoggerSDK;

package/dist/cjs/loggerSDK.js

@@ -0,0 +1,426 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/loggerSDK.ts
+var loggerSDK_exports = {};
+__export(loggerSDK_exports, {
+  LoggerSDK: () => LoggerSDK,
+  default: () => loggerSDK_default
+});
+module.exports = __toCommonJS(loggerSDK_exports);
+var import_dbQueue = __toESM(require("./dbQueue"));
+var import_transportAdapter = require("./transportAdapter");
+var import_utils = require("./utils");
+var import_storeAdapter = require("./storeAdapter");
+var LoggerSDK = class {
+  constructor(options) {
+    this.inMemoryQueue = [];
+    this.seq = 0;
+    this.timerId = null;
+    this.storage = null;
+    this.closed = false;
+    this.idbQueue = null;
+    this.flushing = false;
+    const defaults = {
+      endpoints: options.endpoints || {},
+      appId: options.appId || "",
+      env: options.env || (() => {
+        if ((0, import_utils.isWeChatMiniProgram)())
+          return "wechat";
+        if ((0, import_utils.isBrowser)())
+          return "h5";
+        return "unknown";
+      })(),
+      batchSize: options.batchSize || 10,
+      flushInterval: options.flushInterval || 5e3,
+      retryCount: options.retryCount || 3,
+      retryBase: options.retryBase || 300,
+      storageKey: options.storageKey || "logger_sdk_cache_v2",
+      maxCacheSize: options.maxCacheSize || 2e3,
+      timeout: options.timeout || 1e4,
+      debug: !!options.debug,
+      transport: options.transport || import_transportAdapter.defaultTransport,
+      globalHeaders: options.globalHeaders || {},
+      enableAutoPV: options.enableAutoPV !== false,
+      enablePerf: options.enablePerf !== false,
+      usePixel: options.usePixel || false,
+      pixelParam: options.pixelParam || "data",
+      maxPixelUrlLen: options.maxPixelUrlLen || 1900
+    };
+    this.opts = Object.assign(defaults, options);
+    this.env = this.opts.env;
+    if (this.env === "wechat")
+      this.storage = (0, import_storeAdapter.wechatStorage)(this.opts.storageKey);
+    else if (this.env === "h5")
+      this.storage = (0, import_storeAdapter.browserStorage)(this.opts.storageKey);
+    else
+      this.storage = null;
+    if ((0, import_utils.isBrowser)() && (0, import_utils.isIndexedDBAvailable)()) {
+      this.idbQueue = new import_dbQueue.default("logger_sdk_db", "queue");
+      this.idbQueue.open().catch(() => {
+        this.idbQueue = null;
+      });
+    }
+    this.loadFromStorage().then(() => {
+      if (this.opts.flushInterval > 0)
+        this.startTimer();
+    });
+    this.attachGlobalHandlers();
+    if (this.opts.enableAutoPV && this.env === "h5")
+      this.installAutoPV();
+    if (this.opts.enablePerf && this.env === "h5") {
+      if (document.readyState === "complete")
+        this.collectPerf();
+      else
+        window.addEventListener("load", () => this.collectPerf());
+    }
+  }
+  logDebug(...args) {
+    if (this.opts.debug)
+      console.debug("[LoggerSDK]", ...args);
+  }
+  async loadFromStorage() {
+    if (!this.storage)
+      return;
+    try {
+      const raw = await this.storage.get();
+      if (raw) {
+        const arr = JSON.parse(raw);
+        this.inMemoryQueue = arr.concat(this.inMemoryQueue).slice(-this.opts.maxCacheSize);
+        this.logDebug("loaded persisted queue", this.inMemoryQueue.length);
+      }
+    } catch (e) {
+      this.logDebug("load persisted fail", e);
+    }
+  }
+  async persistToStorage() {
+    if (!this.storage)
+      return;
+    try {
+      await this.storage.set((0, import_utils.safeStringify)(this.inMemoryQueue));
+      this.logDebug("persisted queue", this.inMemoryQueue.length);
+    } catch (e) {
+      this.logDebug("persist fail", e);
+    }
+  }
+  startTimer() {
+    if (this.timerId)
+      return;
+    this.timerId = setInterval(() => this.flush().catch(() => {
+    }), this.opts.flushInterval);
+  }
+  stopTimer() {
+    if (!this.timerId)
+      return;
+    clearInterval(this.timerId);
+    this.timerId = null;
+  }
+  // 将事件入队（先到内存，再持久化）
+  async track(event, headers) {
+    if (this.closed)
+      return;
+    this.seq += 1;
+    const e = {
+      type: event.type || "custom",
+      time: event.time || (0, import_utils.now)(),
+      user: event.user || void 0,
+      ctx: event.ctx || {},
+      level: event.level || "info",
+      seq: this.seq
+    };
+    this.inMemoryQueue.push(e);
+    this.logDebug("enqueue", e);
+    await this.persistToStorage();
+    if (this.idbQueue) {
+      try {
+        await this.idbQueue.add(e);
+      } catch (err) {
+        this.logDebug("idb add fail", err);
+      }
+    }
+    if (this.inMemoryQueue.length >= this.opts.batchSize) {
+      await this.flush(headers).catch(() => {
+      });
+    }
+  }
+  // flush：从队列中取一批发送（按 level 分 endpoint，支持部分成功剔除）
+  async flush(extraHeaders) {
+    if (this.closed)
+      return;
+    if (this.inMemoryQueue.length === 0)
+      return;
+    if (this.flushing)
+      return;
+    this.flushing = true;
+    try {
+      const batch = this.inMemoryQueue.slice(0, this.opts.batchSize);
+      const groups = {};
+      batch.forEach((ev) => {
+        const level = ev.level || "info";
+        (groups[level] = groups[level] || []).push(ev);
+      });
+      const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+      const sendGroup = (level, events) => {
+        const endpoint = this.opts.endpoints[level] || this.opts.endpoints.default;
+        const payload = { appId: this.opts.appId, env: this.env, ts: (0, import_utils.now)(), level, events };
+        const maxTry = this.opts.retryCount;
+        const attemptOnce = (attempt) => {
+          const transportOpts = { ...this.opts, endpoint, headers: { ...this.opts.globalHeaders || {}, ...extraHeaders || {} } };
+          return this.opts.transport(payload, transportOpts).then(() => true).catch(async (err) => {
+            const next = attempt + 1;
+            this.logDebug("send fail", level, next, err);
+            if (next > maxTry)
+              return false;
+            const wait = (this.opts.retryBase || 300) * 2 ** (next - 1);
+            await delay(wait);
+            return attemptOnce(next);
+          });
+        };
+        return attemptOnce(0).then((ok) => ({ ok, level, events }));
+      };
+      const results = await Promise.all(Object.keys(groups).map((level) => sendGroup(level, groups[level])));
+      const successLevels = new Set(results.filter((r) => r.ok).map((r) => r.level));
+      const allOk = results.length > 0 && results.every((r) => r.ok);
+      if (!allOk && successLevels.size === 0) {
+        this.logDebug("batch send failed, keep batch in queue");
+        return;
+      }
+      const removeSeq = new Set(batch.filter((e) => successLevels.has(e.level || "info")).map((e) => e.seq));
+      this.inMemoryQueue = this.inMemoryQueue.filter((x) => !removeSeq.has(x.seq));
+      await this.persistToStorage();
+      if (allOk && this.idbQueue) {
+        try {
+          await this.idbQueue.clear();
+        } catch (e) {
+          this.logDebug("idb clear fail", e);
+        }
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  // 将队列尽力全部发送（分批轮询 + 安全阈值）
+  async flushAll() {
+    let safety = 0;
+    return new Promise((resolve) => {
+      const tick = async () => {
+        safety += 1;
+        if (this.inMemoryQueue.length === 0 || safety >= 200)
+          return resolve();
+        if (!this.flushing) {
+          try {
+            await this.flush();
+          } catch {
+          }
+        }
+        setTimeout(tick, 50);
+      };
+      tick();
+    });
+  }
+  async identify(user) {
+    this.opts.appId = user && user.appId || this.opts.appId;
+    this.logDebug("identify", user);
+  }
+  async setCommon(params) {
+    Object.assign(this.opts, params);
+    this.logDebug("setCommon", params);
+  }
+  destroy() {
+    this.stopTimer();
+    this.closed = true;
+  }
+  // ========== 自动采集与错误处理 ===========
+  attachGlobalHandlers() {
+    if (this.env === "h5" && typeof window !== "undefined") {
+      const win = window;
+      win.addEventListener && win.addEventListener("error", (ev) => {
+        try {
+          this.track({ type: "error", level: "error", ctx: { message: ev.message, filename: ev.filename, lineno: ev.lineno, colno: ev.colno, stack: ev.error && ev.error.stack } });
+        } catch {
+        }
+      });
+      win.addEventListener && win.addEventListener("unhandledrejection", (ev) => {
+        try {
+          this.track({ type: "error", level: "error", ctx: { reason: ev.reason && (ev.reason.stack || ev.reason) } });
+        } catch {
+        }
+      });
+      win.addEventListener && win.addEventListener(
+        "error",
+        (ev) => {
+          if (ev.target && (ev.target.src || ev.target.href)) {
+            try {
+              this.track({ type: "error", level: "warn", ctx: { resource: ev.target.src || ev.target.href, tag: ev.target.tagName } });
+            } catch {
+            }
+          }
+        },
+        true
+      );
+      document.addEventListener && document.addEventListener("visibilitychange", () => {
+        try {
+          if (document.visibilityState === "hidden")
+            this.flushBeacon();
+        } catch {
+        }
+      });
+      win.addEventListener && win.addEventListener("pagehide", () => {
+        try {
+          this.flushBeacon();
+        } catch {
+        }
+      });
+      win.addEventListener && win.addEventListener("beforeunload", () => {
+        try {
+          this.flushBeacon();
+        } catch {
+        }
+      });
+    }
+  }
+  // 自动 PV（single-page 支持简单的 history 池监听）
+  installAutoPV() {
+    if (!(0, import_utils.isBrowser)())
+      return;
+    const { history, location } = window;
+    const { pushState } = history;
+    const { replaceState } = history;
+    const onUrlChange = () => {
+      try {
+        this.track({ type: "pageview", level: "info", ctx: { path: location.pathname + location.search, title: document.title } });
+      } catch {
+      }
+    };
+    history.pushState = function(...args) {
+      pushState.apply(this, args);
+      window.dispatchEvent(new Event("locationchange"));
+    };
+    history.replaceState = function(...args) {
+      replaceState.apply(this, args);
+      window.dispatchEvent(new Event("locationchange"));
+    };
+    window.addEventListener("popstate", () => window.dispatchEvent(new Event("locationchange")));
+    window.addEventListener("locationchange", onUrlChange);
+    onUrlChange();
+  }
+  // 性能采集（Navigation timing + Paint）
+  collectPerf() {
+    if (!(0, import_utils.isBrowser)() || !("performance" in window))
+      return;
+    try {
+      const perf = window.performance;
+      const nav = perf.getEntriesByType && perf.getEntriesByType("navigation") && perf.getEntriesByType("navigation")[0];
+      const paints = perf.getEntriesByType ? perf.getEntriesByType("paint") : [];
+      const data = {};
+      if (nav) {
+        data.ttfb = nav.responseStart - nav.requestStart;
+        data.domContentLoaded = nav.domContentLoadedEventEnd - nav.startTime;
+        data.load = nav.loadEventEnd - nav.startTime;
+      } else if (perf.timing) {
+        const t = perf.timing;
+        data.ttfb = t.responseStart - t.requestStart;
+        data.domContentLoaded = t.domContentLoadedEventEnd - t.navigationStart;
+        data.load = t.loadEventEnd - t.navigationStart;
+      }
+      if (paints && paints.length) {
+        paints.forEach((p) => {
+          data[p.name] = p.startTime;
+        });
+      }
+      this.track({ type: "perf", level: "info", ctx: data });
+    } catch (e) {
+      this.logDebug("collect perf fail", e);
+    }
+  }
+  flushBeacon() {
+    if (!(0, import_utils.isBrowser)())
+      return;
+    if (this.inMemoryQueue.length === 0)
+      return;
+    const groups = {};
+    this.inMemoryQueue.forEach((ev) => {
+      const level = ev.level || "info";
+      (groups[level] = groups[level] || []).push(ev);
+    });
+    Object.keys(groups).forEach((level) => {
+      const events = groups[level];
+      const endpoint = this.opts.endpoints[level] || this.opts.endpoints.default;
+      const payload = { appId: this.opts.appId, env: this.env, ts: (0, import_utils.now)(), level, events };
+      const transportOpts = {
+        ...this.opts,
+        endpoint,
+        headers: { ...this.opts.globalHeaders || {} },
+        useBeacon: true,
+        usePixel: this.opts.usePixel,
+        pixelParam: this.opts.pixelParam,
+        maxPixelUrlLen: this.opts.maxPixelUrlLen
+      };
+      try {
+        this.opts.transport(payload, transportOpts);
+      } catch {
+      }
+    });
+  }
+  // 生成简单 Demo 页面（HTML 字符串），方便生成 demo 文档站点
+  //   public generateDemoHtml(opts?: { scriptUrl?: string }) {
+  //     const scriptUrl = (opts && opts.scriptUrl) || 'dist/index.umd.js';
+  //     const html = ```
+  //     <!doctype html>
+  // <html>
+  // <head>
+  // <meta charset="utf-8" />
+  // <title>LoggerSDK Demo</title>
+  // </head>
+  // <body>
+  // <h1>LoggerSDK Demo</h1>
+  // <script src="${scriptUrl}"></script>
+  // <script>
+  // // 通过 UMD 全局 MyLogger 使用
+  // const sdk = new MyLogger.LoggerSDK({
+  //   endpoints: { default: '/api/collect', info: '/api/collect/info', error: '/api/collect/error' },
+  //   appId: 'demo-app',
+  //   debug: true,
+  //   enableAutoPV: true,
+  //   enablePerf: true
+  // });
+  // // 手动埋点
+  // sdk.track({ type: 'custom', level: 'info', ctx: { action: 'click_demo' } });
+  // // 模拟错误
+  // setTimeout(() => { throw new Error('demo error'); }, 2000);
+  // </script>
+  // </body>
+  // </html>```;
+  //     return html;
+  //   }
+};
+var loggerSDK_default = LoggerSDK;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoggerSDK
+});