@qiu_jun/monitors 0.0.7 → 0.0.9

package/README.md

@@ -47,14 +47,23 @@ const monitor = new Monitor({
 |---|---|---|
 | JS 错误 | `error` | 含选择器、白屏检测 |
 | Promise 未捕获 | `unhandledrejection` | |
-| XHR 失败/超时 | `request` | message 格式 `Request failed [500]: GET /api/...` |
+| XHR/fetch 失败/超时 | `request` | 网络失败 `[network]`、HTTP `[500]`；业务错误 `[business 1102]`（需配 `isBusinessError`，见下） |
 | FP/FCP/FMP/LCP | `paint` | 指标在 `device` |
 | DOMContentLoaded/load | `timing` | |
 | 长任务 | `longTask` | duration ≥ 100ms 时 level=WARN |
 
+**业务错误拦截**：后端 HTTP 200 但响应体 `code` 非成功（如 `{ code: 1102, message: '无权限访问' }`）默认不会上报，配置判定函数后按 `request` 事件上报（`message` 形如 `Request failed [business 1102]: POST /api/xxx`，`device.msg` 带后端 message、`device.code` 带错误码）：
+
+```ts
+new Monitor({
+  // ...
+  isBusinessError: body => (body as { code?: number })?.code !== 0, // 项目内约定 code !== 0 即业务错误
+})
+```
+
 ## 错误回放（可选，Web/H5）
 
-基于 rrweb 环形录制用户操作，**出错时**上传最近 30~60 秒回放（独立接口），错误事件通过 `device.replayId` 关联，异常平台用 rrweb-player 播放。小程序无 DOM 不支持。
+基于 rrweb 环形录制用户操作，**出错时**上传最近 15~30 秒回放（独立接口），错误事件通过 `device.replayId` 关联，异常平台用 rrweb-player 播放。小程序无 DOM 不支持。
 
 ```ts
 new Monitor({
@@ -62,9 +71,9 @@ new Monitor({
   replay: {
     enabled: true,
     sampleRate: 1,             // 会话采样 0-1，默认 1
-    bufferSeconds: 60,         // 环形缓冲长度，默认 60
+    bufferSeconds: 30,         // 环形缓冲长度，默认 30秒
     maxUploadsPerSession: 10,  // 单会话上传上限，默认 10
-    minUploadIntervalMs: 30_000,
+    minUploadIntervalMs: 30000,
     captureRequest: false,     // 请求失败是否也触发，默认 false
     maskTextClass: 'rr-mask',  // 文本脱敏类名
     // replayEndpoint: '...',  // 默认由 endpoint 末尾 /report 换成 /replay
@@ -73,6 +82,7 @@ new Monitor({
 ```
 
 - 仅 `error` / `unhandledrejection` 触发上传；回放走独立 `POST {endpoint 前缀}/replay`，失败静默不影响错误上报
+- 同类错误采集去重：顶层 `errorDedupeMs`（默认 `0` 不启用）与 `replay.minUploadIntervalMs` 设为同值（如 `30000`）后，同一错误窗口内 1 条事件必带 1 条回放（1:1），顺带减少上报量
 - 隐私默认：输入值全脱敏；敏感文本加 `.rr-mask`、敏感区域加 `.rr-block`
 - 回放上传需服务端支持（契约见 [backend-integration.md](./backend-integration.md) §2.3）；script 标签（UMD）接入需页面提供 rrweb / pako 的 import map，否则回放静默禁用
 
@@ -89,11 +99,11 @@ monitor.capture({
 ## 构建发布
 
 ```bash
-pnpm build   # tsc → dist/*.js + *.d.ts，vite → dist/monitor.umd.js
+pnpm build   # tsc → dist/*.js + *.d.ts，strip-console 剥离 console.*，vite → dist/monitor.umd.js
 npm publish
 ```
 
-产物：
+产物均不含 `console.*`（调试 `console.log` 与降级 `console.warn` 一并剥离；UMD 由 vite terser `drop_console`，其余由 `scripts/strip-console.mjs`）：
 
 | 路径 | 说明 |
 |---|---|

package/dist/exception/reporter.d.ts

@@ -8,7 +8,7 @@ export declare class ExcReporter {
     private timer;
     private sending;
     constructor(options: ExcSdkOptions, transport: ExcTransport);
-    /** 采样 + 入缓冲 */
+    /** 采样 + 入缓冲：ERROR/FATAL 走 errorSampleRate（默认全量），WARN 及以下走 sampleRate */
     capture(event: ExcEventPayload): void;
     flush(): Promise<void>;
     destroy(): void;

package/dist/exception/reporter.js

@@ -40,15 +40,17 @@ class ExcReporter {
             value: false
         });
     }
-    /** 采样 + 入缓冲 */
+    /** 采样 + 入缓冲：ERROR/FATAL 走 errorSampleRate（默认全量），WARN 及以下走 sampleRate */
     capture(event) {
         var _a, _b, _c, _d, _e;
-        const sampleRate = (_a = this.options.sampleRate) !== null && _a !== void 0 ? _a : 100;
+        const level = (_a = event.level) !== null && _a !== void 0 ? _a : 'ERROR';
+        const isErrorLevel = level === 'ERROR' || level === 'FATAL';
+        const sampleRate = (_b = (isErrorLevel ? this.options.errorSampleRate : this.options.sampleRate)) !== null && _b !== void 0 ? _b : 100;
         if (sampleRate < 100 && Math.random() * 100 >= sampleRate)
             return;
         this.buffer.push({
             ...event,
-            level: (_b = event.level) !== null && _b !== void 0 ? _b : 'ERROR',
+            level,
             occurredAt: (_c = event.occurredAt) !== null && _c !== void 0 ? _c : new Date().toISOString(),
             sdkVersion: (_d = event.sdkVersion) !== null && _d !== void 0 ? _d : exports.SDK_VERSION,
         });

package/dist/exception/types.d.ts

@@ -8,7 +8,10 @@ export interface ExcSdkOptions {
     projectKey: string;
     release?: string;
     environment?: string;
+    /** 低级别事件（WARN/INFO，性能类等）采样率（%），0-100，默认 100 全量 */
     sampleRate?: number;
+    /** 错误事件（ERROR/FATAL）采样率（%），0-100，默认 100 全量；不随 sampleRate 联动，需压错误量时显式调低 */
+    errorSampleRate?: number;
     maxBatch?: number;
     flushInterval?: number;
 }

package/dist/interface/index.d.ts

@@ -15,16 +15,20 @@ export interface IMonitorOptions {
     /** XHR 超时阈值 ms，默认 60000（1 分钟） */
     timeoutDuration?: number;
     maxQueueSize?: number;
+    /** 同类错误采集去重窗口（ms），默认 0 不启用；窗口内 errorType+message+filename 相同的错误只上报一条。建议与 replay.minUploadIntervalMs 同值（如 30000），错误事件与回放 1:1 */
+    errorDedupeMs?: number;
+    /** 业务错误判定：HTTP 2xx 但响应体 code 非成功的接口（如 { code: 1102, message: '无权限访问' }）返回 true 则上报为 request 事件。入参为解析后的响应体（非 JSON / 解析失败跳过）；XHR responseType 为 blob/arraybuffer 时读不到响应体同样跳过。示例：body => (body as any)?.code !== 0 */
+    isBusinessError?: (body: unknown) => boolean;
     /** 错误回放（仅 Web/H5，小程序无 DOM 不支持），默认关闭 */
     replay?: ReplayOptions;
 }
-/** 错误回放配置：环形录制最近操作，出错时上传最近 30~60 秒，经独立接口 + device.replayId 关联异常事件 */
+/** 错误回放配置：环形录制最近操作，出错时上传最近 15~30 秒，经独立接口 + device.replayId 关联异常事件 */
 export interface ReplayOptions {
     /** 开启回放，默认 false */
     enabled?: boolean;
     /** 会话采样率 0-1，默认 1（命中才录制） */
     sampleRate?: number;
-    /** 环形缓冲长度（秒），默认 60（实际覆盖 bufferSeconds/2 ~ bufferSeconds） */
+    /** 环形缓冲长度（秒），默认 30（实际覆盖 bufferSeconds/2 ~ bufferSeconds） */
     bufferSeconds?: number;
     /** 单会话回放上传上限，默认 10 */
     maxUploadsPerSession?: number;
@@ -95,6 +99,11 @@ export interface RequestLog {
     status?: number;
     url?: string;
     method?: string;
+    /** 业务错误详情（isBusinessError 判定命中时填充，如 { code: 1102, message: '无权限访问' }） */
+    business?: {
+        code?: number | string;
+        message?: string;
+    };
     /** 请求发生时页面地址（captureRequest 自动填充） */
     page?: string;
 }

package/dist/miniprogram.d.ts

@@ -50,6 +50,8 @@ export interface MiniProgramMonitorOptions extends ExcSdkOptions {
     interceptLifecycle?: boolean;
     /** 拦截 wx.request 上报失败请求（默认 true，上报自身 URL 除外，防递归） */
     interceptRequest?: boolean;
+    /** 业务错误判定：statusCode 2xx 但响应体 code 非成功时上报，判定方式同 H5 侧 IMonitorOptions.isBusinessError */
+    isBusinessError?: (body: unknown) => boolean;
 }
 export interface MiniProgramMonitor {
     reporter: ExcReporter;

package/dist/miniprogram.js

@@ -10,6 +10,7 @@ exports.createMiniProgramMonitor = createMiniProgramMonitor;
 const reporter_1 = require("./exception/reporter");
 Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return reporter_1.SDK_VERSION; } });
 Object.defineProperty(exports, "createReporter", { enumerable: true, get: function () { return reporter_1.createReporter; } });
+const businessError_1 = require("./utils/businessError");
 /** 从全局取 wx（微信 / uni-app 等均已注入），取不到返回 undefined */
 function getWx() {
     return globalThis.wx;
@@ -143,7 +144,7 @@ function currentPageRoute() {
     }
 }
 /** 拦截 wx.request：失败的请求按 H5 侧 request 事件格式上报（上报自身 URL 除外，防递归） */
-function interceptRequest(wxApi, endpoint, capture) {
+function interceptRequest(wxApi, endpoint, isBusinessError, capture) {
     const original = wxApi.request.bind(wxApi);
     wxApi.request = (options) => {
         var _a;
@@ -154,7 +155,7 @@ function interceptRequest(wxApi, endpoint, capture) {
         return original({
             ...options,
             success: (res) => {
-                var _a, _b;
+                var _a, _b, _c;
                 if (res.statusCode >= 400) {
                     capture({
                         type: 'request',
@@ -162,7 +163,18 @@ function interceptRequest(wxApi, endpoint, capture) {
                         device: { durationMs: Date.now() - start },
                     });
                 }
-                (_b = options === null || options === void 0 ? void 0 : options.success) === null || _b === void 0 ? void 0 : _b.call(options, res);
+                else if (isBusinessError) {
+                    // 业务错误：statusCode 2xx 但响应体 code 非成功（res.data 默认已被 wx 按 JSON 解析）
+                    const business = (0, businessError_1.detectBusinessError)(res.data, isBusinessError);
+                    if (business) {
+                        capture({
+                            type: 'request',
+                            message: `Request failed [business${business.code !== undefined ? ` ${business.code}` : ''}]: ${String((_b = options === null || options === void 0 ? void 0 : options.method) !== null && _b !== void 0 ? _b : 'GET').toUpperCase()} ${url}`,
+                            device: { durationMs: Date.now() - start, msg: business.message, code: business.code },
+                        });
+                    }
+                }
+                (_c = options === null || options === void 0 ? void 0 : options.success) === null || _c === void 0 ? void 0 : _c.call(options, res);
             },
             fail: (err) => {
                 var _a, _b;
@@ -247,7 +259,7 @@ function createMiniProgramMonitor(options) {
         device: { lifecycle: info.lifecycle, duration: info.duration, component: info.component },
     });
     const restoreConstructors = options.interceptLifecycle !== false ? interceptConstructors() : null;
-    const restoreRequest = options.interceptRequest !== false ? interceptRequest(wxApi, options.endpoint, doCapture) : null;
+    const restoreRequest = options.interceptRequest !== false ? interceptRequest(wxApi, options.endpoint, options.isBusinessError, doCapture) : null;
     return {
         reporter,
         capture: doCapture,

package/dist/modules/err.js

@@ -1,74 +1,45 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = onWindowErr;
+
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+}), exports.default = onWindowErr;
+
 const utils_1 = require("../utils");
+
 function onWindowErr() {
-    window.addEventListener('error', event => {
-        console.log("error event: ", event);
-        // 资源加载失败（target 带 src/href，如 img/script/link）噪声多、价值低，不再上报
-        const target = event.target;
-        if (target &&
-            (target.src || target.href)) {
-            return;
-        }
-        // 监听 JS 代码执行出错
-        const lastEvent = (0, utils_1.getLastEvent)(); // 监听到错误后，获取到最后一个交互事件
-        const isWhiteScreen = (0, utils_1.checkWhiteScreen)(); // 检查是否白屏
-        // 1.1、数据建模存储
-        const errorLog = {
-            // kind: "stability", // 监控指标的大类
-            type: "error",
-            errorType: "jsError",
-            message: event.message,
-            filename: event.filename,
-            position: `${event.lineno}:${event.colno}`,
-            stack: (0, utils_1.formatStack)(event.error.stack),
-            selector: lastEvent ? (0, utils_1.getSelector)() : "",
-            isWhiteScreen,
-        };
-        console.log("js error log: ", errorLog);
-        // 1.2、上报数据
-        // @ts-ignore
-        this.send(errorLog);
-    }, true);
-    // promise
-    window.addEventListener('unhandledrejection', event => {
-        console.log("Promise error event: ", event);
-        const lastEvent = (0, utils_1.getLastEvent)(); // 监听到错误后，获取到最后一个交互事件
-        let message;
-        const reason = event.reason; // Promise 失败的原因
-        let filename;
-        let line = 0;
-        let column = 0;
-        let stack = "";
-        if (typeof event.reason === "string") {
-            // 情况 1、是 Promise reject 抛出的错误（没有办法获取 stack 等信息）
-            message = reason;
-        }
-        else if (typeof reason === "object") {
-            message = reason.message;
-            // 情况 2、是 Promise 中 JS 代码执行出错
-            if (reason.stack) {
-                const matchResult = reason.stack.match(/at\s+(.+):(\d+):(\d+)/);
-                filename = matchResult[1];
-                line = matchResult[2];
-                column = matchResult[3];
-                stack = (0, utils_1.formatStack)(reason.stack);
-            }
-        }
-        // 2.1、数据建模存储
-        const errorLog = {
-            type: "error",
-            errorType: "promiseError", // 错误类型 - Promise 代码错误
-            message,
-            filename,
-            position: `${line}:${column}`,
-            stack,
-            selector: lastEvent ? (0, utils_1.getSelector)() : "",
-        };
-        console.log("promise error log: ", errorLog);
-        // 2.2、上报数据
-        // @ts-ignore
-        this.send(errorLog);
-    }, true);
-}
+  window.addEventListener("error", e => {
+    const t = e.target;
+    if (t && (t.src || t.href)) return;
+    const s = (0, utils_1.getLastEvent)(), r = (0, utils_1.checkWhiteScreen)(), o = {
+      type: "error",
+      errorType: "jsError",
+      message: e.message,
+      filename: e.filename,
+      position: `${e.lineno}:${e.colno}`,
+      stack: (0, utils_1.formatStack)(e.error.stack),
+      selector: s ? (0, utils_1.getSelector)() : "",
+      isWhiteScreen: r
+    };
+    this.send(o);
+  }, !0), window.addEventListener("unhandledrejection", e => {
+    const t = (0, utils_1.getLastEvent)();
+    let s;
+    const r = e.reason;
+    let o, n = 0, i = 0, c = "";
+    if ("string" == typeof e.reason) s = r; else if ("object" == typeof r && (s = r.message, 
+    r.stack)) {
+      const e = r.stack.match(/at\s+(.+):(\d+):(\d+)/);
+      o = e[1], n = e[2], i = e[3], c = (0, utils_1.formatStack)(r.stack);
+    }
+    const a = {
+      type: "error",
+      errorType: "promiseError",
+      message: s,
+      filename: o,
+      position: `${n}:${i}`,
+      stack: c,
+      selector: t ? (0, utils_1.getSelector)() : ""
+    };
+    this.send(a);
+  }, !0);
+}

package/dist/modules/fetch.d.ts

@@ -0,0 +1 @@
+export default function onFetch(): void;

package/dist/modules/fetch.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = onFetch;
+const businessError_1 = require("../utils/businessError");
+/** 主动取消/超时产生的异常名，不算请求失败 */
+const SKIPPED_ERROR_NAMES = ['AbortError', 'TimeoutError'];
+function onFetch() {
+    const originalFetch = typeof window.fetch === 'function' ? window.fetch.bind(window) : undefined;
+    // @ts-ignore
+    const _this = this;
+    if (!originalFetch)
+        return;
+    /** 监控自身的异常不能影响业务请求 */
+    // @ts-ignore
+    const safeCapture = (info) => {
+        try {
+            _this.captureRequest(info);
+        }
+        catch ( /* 静默 */_a) { /* 静默 */ }
+    };
+    window.fetch = function (input, init) {
+        var _a;
+        const reqUrl = typeof input === 'string' ? input : (input instanceof URL ? input.href : input.url);
+        const reqMethod = String((_a = init === null || init === void 0 ? void 0 : init.method) !== null && _a !== void 0 ? _a : (input instanceof Request ? input.method : 'GET')).toUpperCase();
+        // 上报/回放自身 URL 不拦截：防递归，且 clone 读 body 会干扰 keepalive 上报
+        if ((_this.endpoint && reqUrl === _this.endpoint) || (_this.replayEndpoint && reqUrl === _this.replayEndpoint))
+            return originalFetch(input, init);
+        const startTime = new Date().getTime();
+        return originalFetch(input, init).then((res) => {
+            var _a;
+            const duration = new Date().getTime() - startTime;
+            if (res.status >= 400) {
+                safeCapture({
+                    type: 'fetch',
+                    url: reqUrl,
+                    method: reqMethod,
+                    msg: `fetch请求失败: 状态码 ${res.status}`,
+                    duration,
+                    status: res.status,
+                    success: false,
+                    startTime,
+                });
+            }
+            else if (res.status >= 200 && res.status < 300 && _this.isBusinessError) {
+                // 仅对 JSON/文本类响应 clone 读文本判定业务错误，避免缓冲大体积二进制；clone 不消费业务侧响应体
+                const contentType = (_a = res.headers.get('content-type')) !== null && _a !== void 0 ? _a : '';
+                if (contentType.includes('json') || contentType.startsWith('text/')) {
+                    res.clone().text().then((text) => {
+                        var _a;
+                        const business = (0, businessError_1.detectBusinessError)(text, _this.isBusinessError);
+                        if (!business)
+                            return;
+                        safeCapture({
+                            type: 'fetch',
+                            url: reqUrl,
+                            method: reqMethod,
+                            msg: `fetch业务错误: ${(_a = business.message) !== null && _a !== void 0 ? _a : reqUrl}`,
+                            duration: new Date().getTime() - startTime,
+                            status: res.status,
+                            success: false,
+                            business,
+                            startTime,
+                        });
+                    }).catch(() => { });
+                }
+            }
+            return res;
+        }, (err) => {
+            var _a;
+            if (SKIPPED_ERROR_NAMES.includes((_a = err === null || err === void 0 ? void 0 : err.name) !== null && _a !== void 0 ? _a : ''))
+                throw err;
+            safeCapture({
+                type: 'fetch',
+                url: reqUrl,
+                method: reqMethod,
+                msg: `fetch请求错误: ${reqUrl}`,
+                duration: new Date().getTime() - startTime,
+                status: 0,
+                success: false,
+                startTime,
+            });
+            throw err;
+        });
+    };
+}

package/dist/modules/index.d.ts

@@ -3,3 +3,4 @@ export { default as onLongTask } from './longTask';
 export { default as onPaint } from './paint';
 export { default as onTiming } from './timing';
 export { default as onXHR } from './xhr';
+export { default as onFetch } from './fetch';

package/dist/modules/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.onXHR = exports.onTiming = exports.onPaint = exports.onLongTask = exports.onWindowErr = void 0;
+exports.onFetch = exports.onXHR = exports.onTiming = exports.onPaint = exports.onLongTask = exports.onWindowErr = void 0;
 var err_1 = require("./err");
 Object.defineProperty(exports, "onWindowErr", { enumerable: true, get: function () { return __importDefault(err_1).default; } });
 var longTask_1 = require("./longTask");
@@ -14,3 +14,5 @@ var timing_1 = require("./timing");
 Object.defineProperty(exports, "onTiming", { enumerable: true, get: function () { return __importDefault(timing_1).default; } });
 var xhr_1 = require("./xhr");
 Object.defineProperty(exports, "onXHR", { enumerable: true, get: function () { return __importDefault(xhr_1).default; } });
+var fetch_1 = require("./fetch");
+Object.defineProperty(exports, "onFetch", { enumerable: true, get: function () { return __importDefault(fetch_1).default; } });

package/dist/modules/longTask.js

@@ -1,27 +1,28 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = onLongTask;
+
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+}), exports.default = onLongTask;
+
 const utils_1 = require("../utils");
+
 function onLongTask() {
-    if (PerformanceObserver) {
-        const observerLongTask = new PerformanceObserver(list => {
-            list.getEntries().forEach(entry => {
-                // 执行时长大于 100 ms
-                if (entry.duration > 100) {
-                    const lastEvent = (0, utils_1.getLastEvent)();
-                    const log = {
-                        type: "longTask",
-                        startTime: entry.startTime, // 开始时间
-                        duration: entry.duration, // 持续时间
-                        selector: lastEvent ? (0, utils_1.getSelector)() : "",
-                        eventType: lastEvent === null || lastEvent === void 0 ? void 0 : lastEvent.type,
-                    };
-                    console.log("longTask log: ", log);
-                    // @ts-ignore
-                    this.send(log);
-                }
-            });
-        });
-        observerLongTask.observe({ entryTypes: ["longtask"] });
-    }
-}
+  if (PerformanceObserver) {
+    new PerformanceObserver(e => {
+      e.getEntries().forEach(e => {
+        if (e.duration > 100) {
+          const t = (0, utils_1.getLastEvent)(), r = {
+            type: "longTask",
+            startTime: e.startTime,
+            duration: e.duration,
+            selector: t ? (0, utils_1.getSelector)() : "",
+            eventType: null == t ? void 0 : t.type
+          };
+          this.send(r);
+        }
+      });
+    }).observe({
+      entryTypes: [ "longtask" ]
+    });
+  }
+}

package/dist/modules/paint.js

@@ -1,83 +1,45 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = onPaint;
-/** 带历史缓冲的 PerformanceObserver（兼容 SDK 晚于首次绘制才启动） */
-function observeBuffered(type, callback) {
-    if (typeof PerformanceObserver === 'undefined')
-        return null;
-    try {
-        const observer = new PerformanceObserver((list) => {
-            callback(list.getEntries());
-        });
-        // type + buffered 可拿到观察前已产生的条目
-        observer.observe({ type, buffered: true });
-        return observer;
-    }
-    catch (err) {
-        console.warn('[monitor] PerformanceObserver 不支持 type=', type, err);
-        return null;
-    }
+
+function observeBuffered(e, n) {
+  if ("undefined" == typeof PerformanceObserver) return null;
+  try {
+    const t = new PerformanceObserver(e => {
+      n(e.getEntries());
+    });
+    return t.observe({
+      type: e,
+      buffered: !0
+    }), t;
+  } catch (e) {
+    return null;
+  }
 }
-/**
- * 采集绘制指标 FP/FCP/FMP/LCP。
- * 若 SDK 在 window.load 之后初始化，仍会延迟上报（含 buffered 历史指标）。
- */
+
 function onPaint() {
-    if (typeof PerformanceObserver === 'undefined') {
-        console.warn('[monitor] 当前环境不支持 PerformanceObserver，跳过 paint 采集');
-        return;
-    }
-    let FP = null;
-    let FCP = null;
-    let FMP = null;
-    let LCP = null;
-    const observerFPAndFCP = observeBuffered('paint', (entries) => {
-        for (const entry of entries) {
-            if (entry.name === 'first-paint') {
-                FP = entry;
-                console.log('[monitor] FP', FP.startTime);
-            }
-            else if (entry.name === 'first-contentful-paint') {
-                FCP = entry;
-                console.log('[monitor] FCP', FCP.startTime);
-            }
-        }
-    });
-    const observerFMP = observeBuffered('element', (entries) => {
-        if (entries.length > 0) {
-            FMP = entries[0];
-            console.log('[monitor] FMP', FMP.startTime);
-            observerFMP === null || observerFMP === void 0 ? void 0 : observerFMP.disconnect();
-        }
-    });
-    // LCP 会多次更新，上报前再 disconnect
-    const observerLCP = observeBuffered('largest-contentful-paint', (entries) => {
-        if (entries.length > 0) {
-            LCP = entries[entries.length - 1];
-            console.log('[monitor] LCP', LCP.startTime);
-        }
-    });
-    /** load 后再等一段时间，尽量拿到稳定 LCP 再上报 */
-    const scheduleReport = () => {
-        setTimeout(() => {
-            observerLCP === null || observerLCP === void 0 ? void 0 : observerLCP.disconnect();
-            observerFPAndFCP === null || observerFPAndFCP === void 0 ? void 0 : observerFPAndFCP.disconnect();
-            observerFMP === null || observerFMP === void 0 ? void 0 : observerFMP.disconnect();
-            const log = {
-                type: 'paint',
-                FP: FP === null || FP === void 0 ? void 0 : FP.startTime,
-                FCP: FCP === null || FCP === void 0 ? void 0 : FCP.startTime,
-                FMP: FMP === null || FMP === void 0 ? void 0 : FMP.startTime,
-                LCP: LCP === null || LCP === void 0 ? void 0 : LCP.startTime,
-            };
-            console.log('[monitor] paint 上报', log);
-            this.send(log);
-        }, 3000);
-    };
-    if (document.readyState === 'complete') {
-        console.log('[monitor] 页面已 load 完成，延迟补报 paint');
-        scheduleReport();
-        return;
-    }
-    window.addEventListener('load', scheduleReport);
+  if ("undefined" == typeof PerformanceObserver) return;
+  let e = null, n = null, t = null, r = null;
+  const l = observeBuffered("paint", t => {
+    for (const r of t) "first-paint" === r.name ? e = r : "first-contentful-paint" === r.name && (n = r);
+  }), o = observeBuffered("element", e => {
+    e.length > 0 && (t = e[0], null == o || o.disconnect());
+  }), u = observeBuffered("largest-contentful-paint", e => {
+    e.length > 0 && (r = e[e.length - 1]);
+  }), i = () => {
+    setTimeout(() => {
+      null == u || u.disconnect(), null == l || l.disconnect(), null == o || o.disconnect();
+      const i = {
+        type: "paint",
+        FP: null == e ? void 0 : e.startTime,
+        FCP: null == n ? void 0 : n.startTime,
+        FMP: null == t ? void 0 : t.startTime,
+        LCP: null == r ? void 0 : r.startTime
+      };
+      this.send(i);
+    }, 3e3);
+  };
+  "complete" !== document.readyState ? window.addEventListener("load", i) : i();
 }
+
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+}), exports.default = onPaint;