@mtn-ui-z/monitor 0.0.1

package/dist/index.js

@@ -0,0 +1,962 @@
+var u = Object.defineProperty;
+var m = (a, t, e) => t in a ? u(a, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[t] = e;
+var i = (a, t, e) => m(a, typeof t != "symbol" ? t + "" : t, e);
+class f {
+  /**
+   * 构造函数
+   * @param options - 监控配置
+   * @param reportFn - 上报函数
+   */
+  constructor(t, e) {
+    /** 监控配置选项 */
+    i(this, "options");
+    /** 数据上报函数 */
+    i(this, "reportFn");
+    /** 绑定的事件处理器 - JS 错误 */
+    i(this, "boundErrorHandler");
+    /** 绑定的事件处理器 - Promise 未捕获异常 */
+    i(this, "boundPromiseHandler");
+    /** 绑定的事件处理器 - 资源加载错误 */
+    i(this, "boundResourceHandler");
+    /** Vue 错误处理器 */
+    i(this, "vueErrorHandler");
+    this.options = t, this.reportFn = e, this.boundErrorHandler = this.handleError.bind(this), this.boundPromiseHandler = this.handlePromiseReject.bind(this), this.boundResourceHandler = this.handleResourceError.bind(this), this.vueErrorHandler = this.handleVueError.bind(this);
+  }
+  /**
+   * 启动错误监控
+   * 添加全局事件监听器
+   */
+  start() {
+    this.options.errorEnabled && (window.addEventListener("error", this.boundErrorHandler, !0), window.addEventListener("unhandledrejection", this.boundPromiseHandler, !0), window.addEventListener("error", this.boundResourceHandler, !0));
+  }
+  /**
+   * 停止错误监控
+   * 移除所有事件监听器
+   */
+  stop() {
+    window.removeEventListener("error", this.boundErrorHandler, !0), window.removeEventListener("unhandledrejection", this.boundPromiseHandler, !0), window.removeEventListener("error", this.boundResourceHandler, !0);
+  }
+  /**
+   * 创建 Vue 错误处理器
+   * 用于设置到 app.config.errorHandler
+   * @param customHandler - 用户自定义的处理函数（可选），会在监控上报后调用
+   * @returns Vue 错误处理函数
+   */
+  createVueErrorHandler(t) {
+    return (e, o, r) => {
+      this.handleVueError(e, o, r), t && t(e, o, r);
+    };
+  }
+  /**
+   * 注册 Vue 错误处理器（兼容旧版）
+   * @param handler - 用户自定义的 Vue 错误处理函数
+   * @returns Vue 错误处理器函数
+   * @deprecated 请使用 createVueErrorHandler 代替
+   */
+  registerVueHandler(t) {
+    return this.vueErrorHandler = (e, o, r) => {
+      this.handleVueError(e, o, r), t(e, o, r);
+    }, this.vueErrorHandler;
+  }
+  /**
+   * 处理 JS 运行时错误
+   * @param event - ErrorEvent 事件对象
+   */
+  handleError(t) {
+    var o;
+    if (t.message === "ResizeObserver loop limit exceeded" || t.message === "ResizeObserver loop completed with undelivered notifications")
+      return;
+    const e = {
+      type: "error",
+      errorType: "js",
+      message: t.message,
+      stack: (o = t.error) == null ? void 0 : o.stack,
+      url: t.filename,
+      line: t.lineno,
+      column: t.colno,
+      timestamp: Date.now()
+    };
+    this.reportFn(e);
+  }
+  /**
+   * 处理 Promise 未捕获异常
+   * @param event - PromiseRejectionEvent 事件对象
+   */
+  handlePromiseReject(t) {
+    var o, r;
+    const e = {
+      type: "error",
+      errorType: "promise",
+      message: ((o = t.reason) == null ? void 0 : o.message) || String(t.reason),
+      stack: (r = t.reason) == null ? void 0 : r.stack,
+      url: window.location.href,
+      timestamp: Date.now()
+    };
+    this.reportFn(e);
+  }
+  /**
+   * 处理资源加载错误
+   * @param event - 事件对象
+   */
+  handleResourceError(t) {
+    const e = t.target;
+    if (!e || e.tagName !== "SCRIPT" && e.tagName !== "LINK" && e.tagName !== "IMG")
+      return;
+    const o = {
+      type: "error",
+      errorType: "resource",
+      message: `资源加载失败: ${e.src || e.src || e.tagName}`,
+      url: window.location.href,
+      timestamp: Date.now()
+    };
+    this.reportFn(o);
+  }
+  /**
+   * 处理 Vue 组件错误
+   * @param err - Vue 错误对象
+   * @param instance - 触发错误的组件实例
+   * @param info - 错误信息字符串
+   */
+  handleVueError(t, e, o) {
+    const r = {
+      type: "error",
+      errorType: "vue",
+      message: t.message,
+      stack: t.stack,
+      url: `${window.location.href} (${o})`,
+      timestamp: Date.now()
+    };
+    this.reportFn(r);
+  }
+}
+class v {
+  /**
+   * 构造函数
+   * @param options - 监控配置
+   * @param reportFn - 上报函数
+   */
+  constructor(t, e) {
+    /** 监控配置选项 */
+    i(this, "options");
+    /** 数据上报函数 */
+    i(this, "reportFn");
+    /** PerformanceObserver 实例数组，用于停止时清理 */
+    i(this, "observers", []);
+    /** load 事件监听器引用 */
+    i(this, "loadHandler", null);
+    /** CLS 上报定时器引用 */
+    i(this, "clsTimeoutId", null);
+    this.options = t, this.reportFn = e;
+  }
+  /**
+   * 启动性能监控
+   * 采集各类性能指标
+   */
+  start() {
+    this.options.performanceEnabled && (document.readyState === "complete" ? this.reportPagePerformance() : (this.loadHandler = () => {
+      setTimeout(() => this.reportPagePerformance(), 0);
+    }, window.addEventListener("load", this.loadHandler)), this.observeResources(), this.observeFCP(), this.observeLCP(), this.observeCLS(), this.observeFID());
+  }
+  /**
+   * 停止性能监控
+   * 清理所有 observer 和定时器
+   */
+  stop() {
+    this.observers.forEach((t) => {
+      try {
+        t.disconnect();
+      } catch {
+      }
+    }), this.observers = [], this.loadHandler && (window.removeEventListener("load", this.loadHandler), this.loadHandler = null), this.clsTimeoutId && (clearTimeout(this.clsTimeoutId), this.clsTimeoutId = null);
+  }
+  /**
+   * 上报页面基础性能指标
+   * 使用 performance.getEntriesByType('navigation') 获取页面加载各阶段耗时
+   */
+  reportPagePerformance() {
+    const t = performance.getEntriesByType("navigation");
+    if (t && t.length > 0) {
+      const r = t[0];
+      [
+        // 页面完整加载时间
+        { metric: "page", value: r.loadEventEnd - r.startTime },
+        // DNS 查询时间
+        { metric: "dns", value: r.domainLookupEnd - r.domainLookupStart },
+        // TCP 连接时间
+        { metric: "tcp", value: r.connectEnd - r.connectStart },
+        // TTFB (Time To First Byte) - 首字节时间
+        { metric: "ttfb", value: r.responseStart - r.startTime },
+        // 内容下载时间
+        { metric: "download", value: r.responseEnd - r.responseStart }
+      ].forEach(({ metric: s, value: l }) => {
+        l >= 0 && this.reportFn({
+          type: "performance",
+          metric: s,
+          value: l,
+          url: window.location.href,
+          timestamp: Date.now()
+        });
+      });
+    } else {
+      const r = performance.timing;
+      if (!r) return;
+      [
+        // 页面完整加载时间
+        { metric: "page", value: r.loadEventEnd - r.navigationStart },
+        // DNS 查询时间
+        { metric: "dns", value: r.domainLookupEnd - r.domainLookupStart },
+        // TCP 连接时间
+        { metric: "tcp", value: r.connectEnd - r.connectStart },
+        // TTFB (Time To First Byte) - 首字节时间
+        { metric: "ttfb", value: r.responseStart - r.navigationStart }
+      ].forEach(({ metric: s, value: l }) => {
+        l >= 0 && this.reportFn({
+          type: "performance",
+          metric: s,
+          value: l,
+          url: window.location.href,
+          timestamp: Date.now()
+        });
+      });
+    }
+    const o = performance.getEntriesByType("paint").find((r) => r.name === "first-paint");
+    o && this.reportFn({
+      type: "performance",
+      metric: "fp",
+      value: o.startTime,
+      url: window.location.href,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 监听资源加载性能
+   * 使用 PerformanceObserver 监听所有资源请求
+   */
+  observeResources() {
+    try {
+      const t = new PerformanceObserver((e) => {
+        e.getEntries().forEach((o) => {
+          const r = o;
+          r.duration > 100 && this.reportFn({
+            type: "performance",
+            metric: "resource",
+            value: r.duration,
+            url: window.location.href,
+            timestamp: Date.now()
+          });
+        });
+      });
+      t.observe({ entryTypes: ["resource"] }), this.observers.push(t);
+    } catch {
+    }
+  }
+  /**
+   * 监听 First Contentful Paint (FCP)
+   * 首次内容绘制时间
+   */
+  observeFCP() {
+    try {
+      const t = new PerformanceObserver((e) => {
+        const o = e.getEntries(), r = o[o.length - 1];
+        this.reportFn({
+          type: "performance",
+          metric: "fcp",
+          value: r.startTime,
+          url: window.location.href,
+          timestamp: Date.now()
+        });
+      });
+      t.observe({ entryTypes: ["paint"] }), this.observers.push(t);
+    } catch {
+    }
+  }
+  /**
+   * 监听 Largest Contentful Paint (LCP)
+   * 最大内容绘制时间，关键用户体验指标
+   */
+  observeLCP() {
+    try {
+      const t = new PerformanceObserver((e) => {
+        const o = e.getEntries(), r = o[o.length - 1];
+        this.reportFn({
+          type: "performance",
+          metric: "lcp",
+          value: r.startTime,
+          url: window.location.href,
+          timestamp: Date.now()
+        });
+      });
+      t.observe({ entryTypes: ["largest-contentful-paint"] }), this.observers.push(t);
+    } catch {
+    }
+  }
+  /**
+   * 监听 Cumulative Layout Shift (CLS)
+   * 累计布局偏移，衡量页面稳定性
+   */
+  observeCLS() {
+    let t = 0;
+    try {
+      const e = new PerformanceObserver((o) => {
+        for (const r of o.getEntries()) {
+          const n = r;
+          n.hadRecentInput || (t += n.value);
+        }
+      });
+      e.observe({ entryTypes: ["layout-shift"] }), this.observers.push(e), this.clsTimeoutId = setTimeout(() => {
+        this.reportFn({
+          type: "performance",
+          metric: "cls",
+          value: t,
+          url: window.location.href,
+          timestamp: Date.now()
+        });
+      }, 3e3);
+    } catch {
+    }
+  }
+  /**
+   * 监听 First Input Delay (FID)
+   * 首次输入延迟，衡量页面响应性
+   */
+  observeFID() {
+    try {
+      const t = new PerformanceObserver((e) => {
+        const r = e.getEntries()[0];
+        this.reportFn({
+          type: "performance",
+          metric: "fid",
+          value: r.processingStart - r.startTime,
+          url: window.location.href,
+          timestamp: Date.now()
+        });
+      });
+      t.observe({ entryTypes: ["first-input"] }), this.observers.push(t);
+    } catch {
+    }
+  }
+}
+class w {
+  /**
+   * 构造函数
+   * @param options - 监控配置
+   * @param reportFn - 上报函数
+   */
+  constructor(t, e) {
+    /** 监控配置选项 */
+    i(this, "options");
+    /** 数据上报函数 */
+    i(this, "reportFn");
+    /** 当前用户 ID */
+    i(this, "userId");
+    /** 原始的 pushState 方法 */
+    i(this, "originalPushState", null);
+    /** 原始的 replaceState 方法 */
+    i(this, "originalReplaceState", null);
+    /** popstate 事件回调 */
+    i(this, "popstateHandler", null);
+    /** 是否已启动 */
+    i(this, "isStarted", !1);
+    this.options = t, this.reportFn = e;
+  }
+  /**
+   * 启动页面访问监控
+   * 首次访问立即上报，并监听路由变化
+   */
+  start() {
+    this.options.pvEnabled && (this.isStarted || (this.report(), this.observeRouter(), this.isStarted = !0));
+  }
+  /**
+   * 停止页面访问监控
+   * 恢复原始方法，移除事件监听
+   */
+  stop() {
+    this.originalPushState && (window.history.pushState = this.originalPushState, this.originalPushState = null), this.originalReplaceState && (window.history.replaceState = this.originalReplaceState, this.originalReplaceState = null), this.popstateHandler && (window.removeEventListener("popstate", this.popstateHandler), this.popstateHandler = null), this.isStarted = !1;
+  }
+  /**
+   * 手动触发一次 PV 上报
+   * 可用于路由切换后手动上报
+   */
+  report() {
+    const t = {
+      type: "pv",
+      url: window.location.href,
+      referrer: document.referrer,
+      userId: this.userId,
+      timestamp: Date.now()
+    };
+    this.reportFn(t);
+  }
+  /**
+   * 设置用户 ID
+   * @param userId - 用户唯一标识
+   */
+  setUserId(t) {
+    this.userId = t;
+  }
+  /**
+   * 监听路由变化
+   * 支持浏览器前进后退、pushState
+   * 注意：仅在 pushState 和 popstate 时上报，不在 replaceState 时上报。
+   * Vue Router 4 在一次 router.push() 中会先 replaceState 再 pushState，若 replaceState 也上报会导致同一次跳转产生两次 PV。
+   */
+  observeRouter() {
+    this.originalPushState = window.history.pushState.bind(window.history), this.originalReplaceState = window.history.replaceState.bind(window.history), this.popstateHandler = () => {
+      this.report();
+    }, window.addEventListener("popstate", this.popstateHandler), window.history.pushState = (...t) => {
+      this.originalPushState(...t), this.report();
+    }, window.history.replaceState = (...t) => {
+      this.originalReplaceState(...t);
+    };
+  }
+}
+class b {
+  /**
+   * 构造函数
+   * @param options - 监控配置
+   * @param reportFn - 上报函数
+   */
+  constructor(t, e) {
+    /** 监控配置选项 */
+    i(this, "options");
+    /** 数据上报函数 */
+    i(this, "reportFn");
+    /** 原始 fetch 方法 */
+    i(this, "originalFetch", null);
+    /** 原始 XMLHttpRequest */
+    i(this, "originalXhr", null);
+    /** 是否已启动 */
+    i(this, "isStarted", !1);
+    this.options = t, this.reportFn = e;
+  }
+  /**
+   * 启动 API 监控
+   */
+  start() {
+    this.isStarted || this.options.apiEnabled && (this.interceptFetch(), this.interceptXhr(), this.isStarted = !0);
+  }
+  /**
+   * 停止 API 监控
+   */
+  stop() {
+    this.originalFetch && (window.fetch = this.originalFetch, this.originalFetch = null), this.originalXhr && (window.XMLHttpRequest = this.originalXhr, this.originalXhr = null), this.isStarted = !1;
+  }
+  /**
+   * 拦截 fetch 请求
+   */
+  interceptFetch() {
+    this.originalFetch = window.fetch.bind(window), window.fetch = async (...t) => {
+      var h;
+      const e = Date.now(), o = typeof t[0] == "string" ? t[0] : t[0].url, r = ((h = t[1]) == null ? void 0 : h.method) || "GET";
+      let n = null, s = null;
+      try {
+        n = await this.originalFetch(...t);
+      } catch (d) {
+        s = d;
+      }
+      const l = Date.now() - e, c = (n == null ? void 0 : n.status) || 0;
+      if (this.reportFn({
+        type: "api",
+        url: o,
+        method: r.toUpperCase(),
+        status: c,
+        duration: l,
+        success: c >= 200 && c < 400 && !s,
+        error: s ? s.message : c >= 400 ? `HTTP ${c}` : void 0,
+        timestamp: Date.now()
+      }), s)
+        throw s;
+      return n;
+    };
+  }
+  /**
+   * 拦截 XMLHttpRequest
+   */
+  interceptXhr() {
+    const t = window.XMLHttpRequest;
+    this.originalXhr = t, window.XMLHttpRequest = class extends t {
+      constructor() {
+        super(...arguments);
+        i(this, "_startTime", 0);
+        i(this, "_url", "");
+        i(this, "_method", "GET");
+      }
+      open(r, n, s = !0, l, c) {
+        return this._method = r.toUpperCase(), this._url = n, super.open(r, n, s, l ?? void 0, c ?? void 0);
+      }
+      send(r) {
+        return this._startTime = Date.now(), this.addEventListener("loadend", () => {
+          const n = Date.now() - this._startTime, s = this.status;
+          e({
+            type: "api",
+            url: this._url,
+            method: this._method,
+            status: s,
+            duration: n,
+            success: s >= 200 && s < 400,
+            error: s >= 400 ? `HTTP ${s}` : void 0,
+            timestamp: Date.now()
+          });
+        }), super.send(r);
+      }
+    };
+    const e = (o) => {
+      this.reportFn(o);
+    };
+  }
+}
+class y {
+  /**
+   * 构造函数
+   * @param options - 监控配置
+   * @param reportFn - 上报函数
+   */
+  constructor(t, e) {
+    /** 监控配置选项 */
+    i(this, "options");
+    /** 数据上报函数 */
+    i(this, "reportFn");
+    /** 是否已启动 */
+    i(this, "isStarted", !1);
+    /** 点击事件处理器（用于 stop 时移除） */
+    i(this, "boundClickHandler", null);
+    /** 滚动事件处理器（用于 stop 时移除） */
+    i(this, "boundScrollHandler", null);
+    /** 可见性变化处理器（用于 stop 时移除） */
+    i(this, "boundVisibilityHandler", null);
+    this.options = t, this.reportFn = e;
+  }
+  /**
+   * 启动用户行为监控
+   */
+  start() {
+    this.isStarted || this.options.behaviorEnabled && (this.observeClick(), this.observeScroll(), this.observeVisibility(), this.isStarted = !0);
+  }
+  /**
+   * 停止用户行为监控
+   */
+  stop() {
+    this.isStarted && (this.boundClickHandler && (document.removeEventListener("click", this.boundClickHandler, !0), this.boundClickHandler = null), this.boundScrollHandler && (window.removeEventListener("scroll", this.boundScrollHandler, { passive: !0 }), this.boundScrollHandler = null), this.boundVisibilityHandler && (document.removeEventListener("visibilitychange", this.boundVisibilityHandler), this.boundVisibilityHandler = null), this.isStarted = !1);
+  }
+  /**
+   * 监听点击事件
+   */
+  observeClick() {
+    this.boundClickHandler = (t) => {
+      var l;
+      const e = t.target;
+      if (!e) return;
+      const o = [];
+      let r = e;
+      for (; r && r !== document.body; ) {
+        const c = r.tagName.toLowerCase(), h = r.id ? `#${r.id}` : "", d = r.className ? `.${r.className.split(" ").join(".")}` : "";
+        c !== "body" && o.unshift(`${c}${h}${d}`), r = r.parentElement;
+      }
+      const n = e.getAttribute("data-monitor-id"), s = e.getAttribute("data-monitor-label");
+      this.reportFn({
+        type: "behavior",
+        behaviorType: "click",
+        element: e.tagName.toLowerCase(),
+        text: ((l = e.textContent) == null ? void 0 : l.slice(0, 50)) || "",
+        path: o.join(" > "),
+        monitorId: n || void 0,
+        monitorLabel: s || void 0,
+        x: t.clientX,
+        y: t.clientY,
+        timestamp: Date.now()
+      });
+    }, document.addEventListener("click", this.boundClickHandler, !0);
+  }
+  /**
+   * 监听滚动事件
+   */
+  observeScroll() {
+    let t = 0;
+    const e = 1e3;
+    this.boundScrollHandler = () => {
+      const o = Date.now();
+      if (o - t < e) return;
+      t = o;
+      const r = window.scrollY || document.documentElement.scrollTop, n = document.documentElement.scrollHeight, s = document.documentElement.clientHeight, l = n - s, c = l > 0 ? Math.round(r / l * 100) : 0;
+      this.reportFn({
+        type: "behavior",
+        behaviorType: "scroll",
+        scrollTop: r,
+        scrollPercent: c,
+        timestamp: Date.now()
+      });
+    }, window.addEventListener("scroll", this.boundScrollHandler, { passive: !0 });
+  }
+  /**
+   * 监听页面可见性变化
+   */
+  observeVisibility() {
+    this.boundVisibilityHandler = () => {
+      document.visibilityState === "hidden" ? this.reportFn({
+        type: "behavior",
+        behaviorType: "pageHide",
+        timestamp: Date.now()
+      }) : document.visibilityState === "visible" && this.reportFn({
+        type: "behavior",
+        behaviorType: "pageShow",
+        timestamp: Date.now()
+      });
+    }, document.addEventListener("visibilitychange", this.boundVisibilityHandler);
+  }
+}
+class g {
+  /**
+   * 构造函数
+   * @param options - 监控配置
+   * @param reportFn - 上报函数
+   */
+  constructor(t, e) {
+    /** 监控配置选项 */
+    i(this, "options");
+    /** 数据上报函数 */
+    i(this, "reportFn");
+    this.options = t, this.reportFn = e;
+  }
+  /**
+   * 上报自定义事件
+   * @param eventName - 事件名称
+   * @param eventData - 事件数据
+   */
+  report(t, e) {
+    this.reportFn({
+      type: "custom",
+      eventName: t,
+      data: e,
+      url: window.location.href,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 上报页面停留事件
+   * @param duration - 停留时长（毫秒）
+   */
+  reportStay(t) {
+    this.reportFn({
+      type: "custom",
+      eventName: "page_stay",
+      data: { duration: t },
+      url: window.location.href,
+      timestamp: Date.now()
+    });
+  }
+}
+class S {
+  /**
+   * 构造函数
+   * @param options - 监控配置
+   * @param reportFn - 上报函数
+   */
+  constructor(t, e) {
+    /** 监控配置选项 */
+    i(this, "options");
+    /** 数据上报函数 */
+    i(this, "reportFn");
+    /** PerformanceObserver 实例 */
+    i(this, "observer", null);
+    /** 是否已启动 */
+    i(this, "isStarted", !1);
+    /** 内存信息轮询定时器 */
+    i(this, "memoryInterval", null);
+    this.options = t, this.reportFn = e;
+  }
+  /**
+   * 启动长任务监控
+   */
+  start() {
+    this.isStarted || this.options.longTaskEnabled && (this.observeLongTask(), this.observeMemory(), this.isStarted = !0);
+  }
+  /**
+   * 停止长任务监控
+   */
+  stop() {
+    if (this.observer) {
+      try {
+        this.observer.disconnect();
+      } catch {
+      }
+      this.observer = null;
+    }
+    this.memoryInterval && (clearInterval(this.memoryInterval), this.memoryInterval = null), this.isStarted = !1;
+  }
+  /**
+   * 监控 Long Task
+   * Long Task 是指执行时间超过 50ms 的任务
+   */
+  observeLongTask() {
+    try {
+      this.observer = new PerformanceObserver((t) => {
+        for (const e of t.getEntries()) {
+          const o = e;
+          this.reportFn({
+            type: "longtask",
+            taskType: "longTask",
+            duration: o.duration,
+            attribution: o.attribution ? JSON.stringify(o.attribution) : void 0,
+            url: window.location.href,
+            timestamp: Date.now()
+          });
+        }
+      }), this.observer.observe({ entryTypes: ["longtask"] });
+    } catch {
+    }
+  }
+  /**
+   * 监控内存使用情况
+   * 兼容新版 Performance.memory 和旧版 performance.msMemoryUsageInfo
+   */
+  observeMemory() {
+    const t = () => {
+      if ("memory" in performance) {
+        const o = performance.memory;
+        return {
+          usedJSHeapSize: o.usedJSHeapSize,
+          totalJSHeapSize: o.totalJSHeapSize
+        };
+      }
+      if ("msMemoryUsage" in performance) {
+        const o = performance.msMemoryUsage;
+        return {
+          usedJSHeapSize: o.totalJSHeapSize,
+          totalJSHeapSize: o.totalJSHeapSize
+        };
+      }
+      return null;
+    };
+    t() && (this.memoryInterval = setInterval(() => {
+      const o = t();
+      if (!o) return;
+      const r = Math.round(o.usedJSHeapSize / 1024 / 1024), n = Math.round(o.totalJSHeapSize / 1024 / 1024), s = Math.round(o.usedJSHeapSize / o.totalJSHeapSize * 100);
+      this.reportFn({
+        type: "longtask",
+        taskType: "memory",
+        usedMemory: r,
+        totalMemory: n,
+        memoryPercent: s,
+        url: window.location.href,
+        timestamp: Date.now()
+      });
+    }, 3e4));
+  }
+}
+class E {
+  /**
+   * 构造函数
+   * @param options - 监控配置
+   */
+  constructor(t) {
+    /** 监控配置选项 */
+    i(this, "options");
+    this.options = t;
+  }
+  /**
+   * 上报监控数据
+   * @param data - 监控数据
+   */
+  report(t) {
+    if (!this.isSampled()) return;
+    const e = {
+      ...t,
+      appId: this.options.appId,
+      sdkKey: this.options.sdkKey,
+      env: this.options.env
+    };
+    if (this.options.report) {
+      this.options.report(e);
+      return;
+    }
+    this.options.reportUrl && this.defaultReport(e);
+  }
+  /**
+   * 判断是否在采样范围内
+   * @returns 是否应该上报
+   */
+  isSampled() {
+    const t = this.options.sampleRate ?? 1;
+    return Math.random() < t;
+  }
+  /**
+   * 默认上报实现
+   * 优先使用 sendBeacon，回退使用 fetch
+   * @param data - 监控数据
+   */
+  defaultReport(t) {
+    const e = this.options.reportUrl;
+    if (navigator.sendBeacon) {
+      const o = new Blob([JSON.stringify(t)], { type: "application/json" });
+      navigator.sendBeacon(e, o);
+    } else
+      fetch(e, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(t),
+        // keepalive 确保页面卸载时请求不中断
+        keepalive: !0
+      }).catch(() => {
+      });
+  }
+}
+class H {
+  constructor() {
+    /** 监控配置选项 */
+    i(this, "options", {});
+    /** 错误监控模块 */
+    i(this, "errorMonitor");
+    /** 性能监控模块 */
+    i(this, "performanceMonitor");
+    /** PV 监控模块 */
+    i(this, "pvMonitor");
+    /** API 监控模块 */
+    i(this, "apiMonitor");
+    /** 用户行为监控模块 */
+    i(this, "behaviorMonitor");
+    /** 自定义事件监控模块 */
+    i(this, "customMonitor");
+    /** 长任务监控模块 */
+    i(this, "longTaskMonitor");
+    /** 上报管理模块 */
+    i(this, "reportManager");
+    /** 当前用户 ID */
+    i(this, "userId");
+    /** 是否已初始化 */
+    i(this, "isInited", !1);
+  }
+  /**
+   * 初始化监控 SDK
+   * @param options - 监控配置选项
+   */
+  init(t) {
+    if (this.isInited) {
+      console.warn("[mtn-monitor] Already initialized");
+      return;
+    }
+    this.options = {
+      errorEnabled: !0,
+      performanceEnabled: !0,
+      pvEnabled: !0,
+      apiEnabled: !0,
+      behaviorEnabled: !1,
+      // 默认关闭，避免过多上报
+      longTaskEnabled: !1,
+      // 默认关闭，因为有性能开销
+      sampleRate: 1,
+      env: "production",
+      ...t
+    }, this.reportManager = new E(this.options);
+    const e = (o) => {
+      var r;
+      (r = this.reportManager) == null || r.report(o);
+    };
+    this.errorMonitor = new f(this.options, e), this.performanceMonitor = new v(this.options, e), this.pvMonitor = new w(this.options, e), this.apiMonitor = new b(this.options, e), this.behaviorMonitor = new y(this.options, e), this.customMonitor = new g(this.options, e), this.longTaskMonitor = new S(this.options, e), this.errorMonitor.start(), this.performanceMonitor.start(), this.pvMonitor.start(), this.apiMonitor.start(), this.behaviorMonitor.start(), this.longTaskMonitor.start(), this.isInited = !0;
+  }
+  /**
+   * 手动上报错误
+   * @param error - Error 对象
+   * @param errorType - 错误类型
+   */
+  reportError(t, e = "js") {
+    if (!this.reportManager) {
+      console.warn("[mtn-monitor] Please call init() first");
+      return;
+    }
+    this.reportManager.report({
+      type: "error",
+      errorType: e,
+      message: t.message,
+      stack: t.stack,
+      url: window.location.href,
+      userId: this.userId,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 手动上报性能数据
+   * @param metric - 性能指标类型
+   * @param value - 指标值（毫秒）
+   */
+  reportPerformance(t, e) {
+    if (!this.reportManager) {
+      console.warn("[mtn-monitor] Please call init() first");
+      return;
+    }
+    this.reportManager.report({
+      type: "performance",
+      metric: t,
+      value: e,
+      url: window.location.href,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * 手动上报页面访问（PV）
+   */
+  reportPv() {
+    if (!this.pvMonitor) {
+      console.warn("[mtn-monitor] Please call init() first");
+      return;
+    }
+    this.pvMonitor.report();
+  }
+  /**
+   * 手动上报自定义事件
+   * @param eventName - 事件名称
+   * @param eventData - 事件数据
+   */
+  reportCustomEvent(t, e) {
+    if (!this.customMonitor) {
+      console.warn("[mtn-monitor] Please call init() first");
+      return;
+    }
+    this.customMonitor.report(t, e);
+  }
+  /**
+   * 设置用户 ID
+   * 用于关联用户行为
+   * @param userId - 用户唯一标识
+   */
+  setUserId(t) {
+    var e;
+    this.userId = t, (e = this.pvMonitor) == null || e.setUserId(t);
+  }
+  /**
+   * 销毁监控实例
+   * 停止所有监控，释放资源
+   */
+  destroy() {
+    var t, e, o, r, n, s;
+    (t = this.errorMonitor) == null || t.stop(), (e = this.performanceMonitor) == null || e.stop(), (o = this.pvMonitor) == null || o.stop(), (r = this.apiMonitor) == null || r.stop(), (n = this.behaviorMonitor) == null || n.stop(), (s = this.longTaskMonitor) == null || s.stop(), this.isInited = !1;
+  }
+}
+const p = new H(), T = {
+  /**
+   * 安装 Vue 插件
+   * @param app - Vue 应用实例
+   * @param options - 监控配置选项
+   */
+  install(a, t) {
+    p.init(t), a.config.globalProperties.$monitor = p, a.provide("monitor", p);
+    const e = a.config.errorHandler;
+    a.config.errorHandler = (o, r, n) => {
+      p.reportError(o, "vue"), e && e(o, r, n);
+    };
+  }
+};
+export {
+  b as ApiMonitor,
+  y as BehaviorMonitor,
+  g as CustomMonitor,
+  f as ErrorMonitor,
+  S as LongTaskMonitor,
+  T as MtnMonitor,
+  v as PerformanceMonitor,
+  w as PvMonitor,
+  E as ReportManager,
+  p as default,
+  p as monitor
+};