sobey-monitor-sdk 1.0.0

package/dist/index.cjs.js

@@ -0,0 +1,1454 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * 默认配置
+ */
+const DEFAULT_CONFIG = {
+    debug: false,
+    sampling: {
+        error: 1,
+        performance: 1,
+        behavior: 1,
+    },
+    report: {
+        maxBufferSize: 10,
+        flushInterval: 5000,
+        timeout: 10000,
+    },
+    error: {
+        enabled: true,
+        jsError: true,
+        promiseError: true,
+        resourceError: true,
+        httpError: true,
+    },
+    performance: {
+        enabled: true,
+        webVitals: true,
+        resource: true,
+        api: true,
+    },
+    behavior: {
+        enabled: true,
+        pv: true,
+        click: true,
+        route: true,
+        maxBreadcrumbs: 20,
+    },
+};
+/**
+ * 配置管理类
+ */
+class ConfigManager {
+    constructor() {
+        this.config = null;
+    }
+    /**
+     * 初始化配置
+     */
+    init(userConfig) {
+        if (!userConfig.appId) {
+            throw new Error('[Monitor] appId is required');
+        }
+        if (!userConfig.dsn) {
+            throw new Error('[Monitor] dsn is required');
+        }
+        this.config = this.mergeConfig(DEFAULT_CONFIG, userConfig);
+    }
+    /**
+     * 获取配置
+     */
+    get() {
+        if (!this.config) {
+            throw new Error('[Monitor] SDK not initialized. Please call init() first.');
+        }
+        return this.config;
+    }
+    /**
+     * 更新配置
+     */
+    update(partialConfig) {
+        if (!this.config) {
+            throw new Error('[Monitor] SDK not initialized. Please call init() first.');
+        }
+        this.config = this.mergeConfig(this.config, partialConfig);
+    }
+    /**
+     * 设置用户信息
+     */
+    setUser(user) {
+        if (this.config) {
+            this.config.user = { ...this.config.user, ...user };
+        }
+    }
+    /**
+     * 是否已初始化
+     */
+    isInitialized() {
+        return this.config !== null;
+    }
+    /**
+     * 合并配置
+     */
+    mergeConfig(defaultConfig, userConfig) {
+        const result = { ...defaultConfig };
+        for (const key in userConfig) {
+            if (Object.prototype.hasOwnProperty.call(userConfig, key)) {
+                const userValue = userConfig[key];
+                const defaultValue = defaultConfig[key];
+                if (userValue !== null &&
+                    typeof userValue === 'object' &&
+                    !Array.isArray(userValue) &&
+                    defaultValue !== null &&
+                    typeof defaultValue === 'object' &&
+                    !Array.isArray(defaultValue)) {
+                    result[key] = this.mergeConfig(defaultValue, userValue);
+                }
+                else {
+                    result[key] = userValue;
+                }
+            }
+        }
+        return result;
+    }
+}
+const config = new ConfigManager();
+
+/**
+ * 上下文管理类
+ */
+class ContextManager {
+    constructor() {
+        this.sessionId = '';
+        this.deviceInfo = null;
+        this.breadcrumbs = [];
+        this.maxBreadcrumbs = 20;
+    }
+    /**
+     * 初始化上下文
+     */
+    init(maxBreadcrumbs = 20) {
+        this.sessionId = this.generateSessionId();
+        this.deviceInfo = this.collectDeviceInfo();
+        this.maxBreadcrumbs = maxBreadcrumbs;
+        this.breadcrumbs = [];
+    }
+    /**
+     * 获取会话 ID
+     */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * 获取设备信息
+     */
+    getDeviceInfo() {
+        return this.deviceInfo;
+    }
+    /**
+     * 添加面包屑
+     */
+    addBreadcrumb(crumb) {
+        const breadcrumb = {
+            ...crumb,
+            timestamp: Date.now(),
+        };
+        this.breadcrumbs.push(breadcrumb);
+        // 限制数量
+        if (this.breadcrumbs.length > this.maxBreadcrumbs) {
+            this.breadcrumbs.shift();
+        }
+    }
+    /**
+     * 获取所有面包屑
+     */
+    getBreadcrumbs() {
+        return [...this.breadcrumbs];
+    }
+    /**
+     * 清空面包屑
+     */
+    clearBreadcrumbs() {
+        this.breadcrumbs = [];
+    }
+    /**
+     * 生成会话 ID
+     */
+    generateSessionId() {
+        const timestamp = Date.now().toString(36);
+        const randomPart = Math.random().toString(36).substring(2, 10);
+        return `${timestamp}-${randomPart}`;
+    }
+    /**
+     * 收集设备信息
+     */
+    collectDeviceInfo() {
+        return {
+            screenWidth: window.screen.width,
+            screenHeight: window.screen.height,
+            viewportWidth: window.innerWidth,
+            viewportHeight: window.innerHeight,
+            devicePixelRatio: window.devicePixelRatio || 1,
+            language: navigator.language,
+            platform: navigator.platform,
+        };
+    }
+}
+const context = new ContextManager();
+
+/**
+ * 浏览器信息工具
+ */
+/**
+ * 获取浏览器 User-Agent
+ */
+function getUserAgent() {
+    return navigator.userAgent;
+}
+/**
+ * 获取当前页面 URL
+ */
+function getPageUrl() {
+    return window.location.href;
+}
+/**
+ * 获取页面来源
+ */
+function getReferrer() {
+    return document.referrer;
+}
+/**
+ * 获取页面标题
+ */
+function getPageTitle() {
+    return document.title;
+}
+/**
+ * 判断是否支持 sendBeacon
+ */
+function supportsSendBeacon() {
+    return typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function';
+}
+/**
+ * 判断页面是否即将卸载
+ */
+function isPageHidden() {
+    return document.visibilityState === 'hidden';
+}
+
+/**
+ * 数据发送器
+ */
+/**
+ * 发送器类
+ */
+class Sender {
+    constructor() {
+        this.buffer = [];
+        this.timer = null;
+    }
+    /**
+     * 发送单条数据
+     */
+    send(data) {
+        const cfg = config.get();
+        // 添加到缓冲区
+        this.buffer.push(data);
+        // 达到缓冲上限，立即发送
+        if (this.buffer.length >= (cfg.report?.maxBufferSize || 10)) {
+            this.flush();
+            return;
+        }
+        // 启动定时器
+        this.scheduleFlush();
+    }
+    /**
+     * 立即发送所有缓冲数据
+     */
+    flush() {
+        if (this.buffer.length === 0)
+            return;
+        const data = [...this.buffer];
+        this.buffer = [];
+        this.clearTimer();
+        this.doSend(data);
+    }
+    /**
+     * 执行发送
+     */
+    doSend(data) {
+        const cfg = config.get();
+        const dsn = cfg.dsn;
+        const payload = JSON.stringify(data);
+        // 页面卸载时优先使用 sendBeacon
+        if (isPageHidden() && supportsSendBeacon()) {
+            this.sendByBeacon(dsn, payload);
+            return;
+        }
+        // 正常情况使用 fetch
+        this.sendByFetch(dsn, payload);
+    }
+    /**
+     * 使用 sendBeacon 发送
+     */
+    sendByBeacon(url, payload) {
+        try {
+            return navigator.sendBeacon(url, payload);
+        }
+        catch (e) {
+            if (config.get().debug) {
+                console.error('[Monitor] sendBeacon failed:', e);
+            }
+            // 降级到 fetch
+            this.sendByFetch(url, payload);
+            return false;
+        }
+    }
+    /**
+     * 使用 fetch 发送
+     */
+    sendByFetch(url, payload) {
+        const cfg = config.get();
+        fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: payload,
+            keepalive: true,
+        }).catch((e) => {
+            if (cfg.debug) {
+                console.error('[Monitor] fetch failed:', e);
+            }
+            // 发送失败，将数据放回缓冲区（可选）
+            // this.buffer.unshift(...JSON.parse(payload));
+        });
+    }
+    /**
+     * 调度延迟发送
+     */
+    scheduleFlush() {
+        if (this.timer)
+            return;
+        const cfg = config.get();
+        const interval = cfg.report?.flushInterval || 5000;
+        this.timer = setTimeout(() => {
+            this.flush();
+        }, interval);
+    }
+    /**
+     * 清除定时器
+     */
+    clearTimer() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}
+const sender = new Sender();
+// 页面卸载时发送剩余数据
+if (typeof window !== 'undefined') {
+    window.addEventListener('beforeunload', () => {
+        sender.flush();
+    });
+    window.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') {
+            sender.flush();
+        }
+    });
+}
+
+/**
+ * 数据上报管理
+ */
+// SDK 版本
+const SDK_VERSION$1 = '1.0.0';
+/**
+ * 上报器类
+ */
+class Reporter {
+    /**
+     * 构建基础数据
+     */
+    buildBaseData() {
+        const cfg = config.get();
+        return {
+            appId: cfg.appId,
+            userId: cfg.user?.userId,
+            sessionId: context.getSessionId(),
+            pageUrl: getPageUrl(),
+            timestamp: Date.now(),
+            userAgent: getUserAgent(),
+            sdkVersion: cfg.version || SDK_VERSION$1,
+        };
+    }
+    /**
+     * 采样判断
+     */
+    shouldSample(type) {
+        const cfg = config.get();
+        const rate = cfg.sampling?.[type] ?? 1;
+        return Math.random() < rate;
+    }
+    /**
+     * 上报错误
+     */
+    reportError(data) {
+        if (!this.shouldSample('error'))
+            return;
+        const cfg = config.get();
+        // 过滤
+        if (cfg.error?.filter) {
+            const fullData = { ...this.buildBaseData(), ...data };
+            if (!cfg.error.filter(fullData))
+                return;
+        }
+        const reportData = {
+            ...this.buildBaseData(),
+            ...data,
+            breadcrumbs: context.getBreadcrumbs(),
+            deviceInfo: context.getDeviceInfo() || undefined,
+        };
+        this.send(reportData);
+    }
+    /**
+     * 上报性能
+     */
+    reportPerformance(data) {
+        if (!this.shouldSample('performance'))
+            return;
+        const reportData = {
+            ...this.buildBaseData(),
+            ...data,
+        };
+        this.send(reportData);
+    }
+    /**
+     * 上报行为
+     */
+    reportBehavior(data) {
+        if (!this.shouldSample('behavior'))
+            return;
+        const reportData = {
+            ...this.buildBaseData(),
+            ...data,
+        };
+        this.send(reportData);
+    }
+    /**
+     * 通用发送
+     */
+    send(data) {
+        const cfg = config.get();
+        if (cfg.debug) {
+            console.log('[Monitor] Report:', data);
+        }
+        sender.send(data);
+    }
+    /**
+     * 立即发送缓冲区数据
+     */
+    flush() {
+        sender.flush();
+    }
+}
+const reporter = new Reporter();
+
+/**
+ * JS 运行时错误捕获插件
+ */
+/**
+ * 安装 JS 错误监听
+ */
+function installJsErrorHandler() {
+    const cfg = config.get();
+    if (!cfg.error?.enabled || !cfg.error?.jsError) {
+        return;
+    }
+    window.addEventListener('error', (event) => {
+        // 过滤资源加载错误（由 resourceError 处理）
+        if (event.target !== window) {
+            return;
+        }
+        const errorData = {
+            type: 'js_error',
+            message: event.message || 'Unknown error',
+            stack: event.error?.stack,
+            filename: event.filename,
+            lineno: event.lineno,
+            colno: event.colno,
+        };
+        // 添加到面包屑
+        context.addBreadcrumb({
+            type: 'console',
+            category: 'error',
+            data: {
+                message: errorData.message,
+                filename: errorData.filename,
+                lineno: errorData.lineno,
+            },
+        });
+        reporter.reportError(errorData);
+    }, true);
+    if (cfg.debug) {
+        console.log('[Monitor] JS error handler installed');
+    }
+}
+
+/**
+ * Promise 未捕获错误插件
+ */
+/**
+ * 安装 Promise 错误监听
+ */
+function installPromiseErrorHandler() {
+    const cfg = config.get();
+    if (!cfg.error?.enabled || !cfg.error?.promiseError) {
+        return;
+    }
+    window.addEventListener('unhandledrejection', (event) => {
+        let message = 'Unhandled Promise rejection';
+        let stack;
+        const reason = event.reason;
+        if (reason instanceof Error) {
+            message = reason.message;
+            stack = reason.stack;
+        }
+        else if (typeof reason === 'string') {
+            message = reason;
+        }
+        else if (reason && typeof reason === 'object') {
+            message = JSON.stringify(reason);
+        }
+        const errorData = {
+            type: 'promise_error',
+            message,
+            stack,
+        };
+        // 添加到面包屑
+        context.addBreadcrumb({
+            type: 'console',
+            category: 'promise_error',
+            data: {
+                message: errorData.message,
+            },
+        });
+        reporter.reportError(errorData);
+    });
+    if (cfg.debug) {
+        console.log('[Monitor] Promise error handler installed');
+    }
+}
+
+/**
+ * 资源加载错误捕获插件
+ */
+/**
+ * 安装资源错误监听
+ */
+function installResourceErrorHandler() {
+    const cfg = config.get();
+    if (!cfg.error?.enabled || !cfg.error?.resourceError) {
+        return;
+    }
+    window.addEventListener('error', (event) => {
+        const target = event.target;
+        // 只处理资源加载错误（target 不是 window）
+        if (!target || target === window || !(target instanceof HTMLElement)) {
+            return;
+        }
+        const tagName = target.tagName.toLowerCase();
+        // 只监控特定标签的资源
+        if (!['img', 'script', 'link', 'video', 'audio', 'source'].includes(tagName)) {
+            return;
+        }
+        // 获取资源 URL
+        const resourceUrl = target.src
+            || target.href
+            || '';
+        if (!resourceUrl) {
+            return;
+        }
+        const errorData = {
+            type: 'resource_error',
+            message: `Failed to load ${tagName}: ${resourceUrl}`,
+            resourceUrl,
+        };
+        // 添加到面包屑
+        context.addBreadcrumb({
+            type: 'request',
+            category: 'resource_error',
+            data: {
+                tagName,
+                resourceUrl,
+            },
+        });
+        reporter.reportError(errorData);
+    }, true); // 使用捕获阶段
+    if (cfg.debug) {
+        console.log('[Monitor] Resource error handler installed');
+    }
+}
+
+/**
+ * HTTP 请求错误拦截插件
+ * 拦截 XMLHttpRequest 和 Fetch 请求
+ */
+// 保存原始方法
+const originalXHROpen = XMLHttpRequest.prototype.open;
+const originalXHRSend = XMLHttpRequest.prototype.send;
+const originalFetch = window.fetch;
+/**
+ * 安装 HTTP 错误拦截
+ */
+function installHttpErrorHandler() {
+    const cfg = config.get();
+    if (!cfg.error?.enabled || !cfg.error?.httpError) {
+        return;
+    }
+    interceptXHR();
+    interceptFetch();
+    if (cfg.debug) {
+        console.log('[Monitor] HTTP error handler installed');
+    }
+}
+/**
+ * 拦截 XMLHttpRequest
+ */
+function interceptXHR() {
+    XMLHttpRequest.prototype.open = function (method, url, async = true, username, password) {
+        // 存储请求信息
+        this._monitorData = {
+            method,
+            url: url.toString(),
+            startTime: 0,
+        };
+        return originalXHROpen.call(this, method, url, async, username, password);
+    };
+    XMLHttpRequest.prototype.send = function (body) {
+        const monitorData = this._monitorData;
+        if (monitorData) {
+            monitorData.startTime = Date.now();
+            monitorData.requestBody = typeof body === 'string' ? body : undefined;
+        }
+        this.addEventListener('loadend', function () {
+            if (!monitorData)
+                return;
+            const duration = Date.now() - monitorData.startTime;
+            const status = this.status;
+            // 添加到面包屑
+            context.addBreadcrumb({
+                type: 'request',
+                category: 'xhr',
+                data: {
+                    method: monitorData.method,
+                    url: monitorData.url,
+                    status,
+                    duration,
+                },
+            });
+            // 只上报错误请求 (4xx, 5xx 或 0)
+            if (status === 0 || status >= 400) {
+                reportHttpError({
+                    method: monitorData.method,
+                    url: monitorData.url,
+                    status,
+                    duration,
+                    requestBody: monitorData.requestBody,
+                    responseBody: this.responseText?.substring(0, 1000), // 限制长度
+                });
+            }
+        });
+        return originalXHRSend.call(this, body);
+    };
+}
+/**
+ * 拦截 Fetch
+ */
+function interceptFetch() {
+    window.fetch = async function (input, init) {
+        const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+        const method = init?.method || 'GET';
+        const startTime = Date.now();
+        const requestBody = typeof init?.body === 'string' ? init.body : undefined;
+        try {
+            const response = await originalFetch.call(window, input, init);
+            const duration = Date.now() - startTime;
+            const status = response.status;
+            // 添加到面包屑
+            context.addBreadcrumb({
+                type: 'request',
+                category: 'fetch',
+                data: {
+                    method,
+                    url,
+                    status,
+                    duration,
+                },
+            });
+            // 只上报错误请求
+            if (!response.ok) {
+                // 克隆响应以读取 body
+                const cloned = response.clone();
+                let responseBody;
+                try {
+                    responseBody = await cloned.text();
+                    responseBody = responseBody.substring(0, 1000);
+                }
+                catch { }
+                reportHttpError({
+                    method,
+                    url,
+                    status,
+                    duration,
+                    requestBody,
+                    responseBody,
+                });
+            }
+            return response;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            // 网络错误
+            context.addBreadcrumb({
+                type: 'request',
+                category: 'fetch',
+                data: {
+                    method,
+                    url,
+                    status: 0,
+                    duration,
+                    error: error.message,
+                },
+            });
+            reportHttpError({
+                method,
+                url,
+                status: 0,
+                duration,
+                requestBody,
+            });
+            throw error;
+        }
+    };
+}
+/**
+ * 上报 HTTP 错误
+ */
+function reportHttpError(httpInfo) {
+    const errorData = {
+        type: 'http_error',
+        message: `HTTP ${httpInfo.status} ${httpInfo.method} ${httpInfo.url}`,
+        httpInfo,
+    };
+    reporter.reportError(errorData);
+}
+
+/**
+ * 白屏检测插件
+ * 使用 DOM 采样检测页面是否白屏
+ */
+// 采样点 - 页面关键区域
+const SAMPLE_POINTS = [
+    { x: 0.5, y: 0.1 }, // 顶部中间
+    { x: 0.25, y: 0.5 }, // 左中
+    { x: 0.5, y: 0.5 }, // 中心
+    { x: 0.75, y: 0.5 }, // 右中
+    { x: 0.5, y: 0.9 }, // 底部中间
+];
+// 无效元素
+const INVALID_ELEMENTS = ['html', 'body', 'head', 'meta', 'link', 'style', 'script'];
+/**
+ * 安装白屏检测
+ */
+function installWhiteScreenDetector() {
+    const cfg = config.get();
+    if (!cfg.error?.enabled) {
+        return;
+    }
+    // 在页面加载完成后检测
+    if (document.readyState === 'complete') {
+        scheduleDetection();
+    }
+    else {
+        window.addEventListener('load', () => {
+            scheduleDetection();
+        });
+    }
+    if (cfg.debug) {
+        console.log('[Monitor] White screen detector installed');
+    }
+}
+/**
+ * 调度检测（延迟执行，给页面渲染时间）
+ */
+function scheduleDetection() {
+    // 延迟 1 秒检测
+    setTimeout(() => {
+        const isWhiteScreen = detectWhiteScreen();
+        if (isWhiteScreen) {
+            reportWhiteScreen();
+        }
+    }, 1000);
+}
+/**
+ * 检测是否白屏
+ */
+function detectWhiteScreen() {
+    const viewportWidth = window.innerWidth;
+    const viewportHeight = window.innerHeight;
+    let emptyPoints = 0;
+    for (const point of SAMPLE_POINTS) {
+        const x = viewportWidth * point.x;
+        const y = viewportHeight * point.y;
+        const element = document.elementFromPoint(x, y);
+        if (!element || isInvalidElement(element)) {
+            emptyPoints++;
+        }
+    }
+    // 如果超过 80% 的采样点是空的，认为是白屏
+    return emptyPoints / SAMPLE_POINTS.length > 0.8;
+}
+/**
+ * 判断是否为无效元素
+ */
+function isInvalidElement(element) {
+    const tagName = element.tagName.toLowerCase();
+    return INVALID_ELEMENTS.includes(tagName);
+}
+/**
+ * 上报白屏错误
+ */
+function reportWhiteScreen() {
+    const errorData = {
+        type: 'white_screen',
+        message: 'White screen detected',
+    };
+    reporter.reportError(errorData);
+}
+
+/**
+ * 错误监控插件入口
+ */
+/**
+ * 安装所有错误监控
+ */
+function installErrorHandlers() {
+    installJsErrorHandler();
+    installPromiseErrorHandler();
+    installResourceErrorHandler();
+    installHttpErrorHandler();
+    installWhiteScreenDetector();
+}
+
+/**
+ * Web Vitals 性能指标采集插件
+ * 采集 FP, FCP, LCP, FID, CLS, TTFB 等核心指标
+ */
+/**
+ * 安装 Web Vitals 采集
+ */
+function installWebVitals() {
+    const cfg = config.get();
+    if (!cfg.performance?.enabled || !cfg.performance?.webVitals) {
+        return;
+    }
+    // 页面加载完成后采集
+    if (document.readyState === 'complete') {
+        collectMetrics();
+    }
+    else {
+        window.addEventListener('load', () => {
+            // 延迟采集，确保 LCP 等指标稳定
+            setTimeout(collectMetrics, 3000);
+        });
+    }
+    if (cfg.debug) {
+        console.log('[Monitor] Web Vitals collector installed');
+    }
+}
+/**
+ * 采集性能指标
+ */
+function collectMetrics() {
+    const metrics = {};
+    // 使用 Performance API
+    if (!window.performance) {
+        return;
+    }
+    // 获取导航计时
+    const navigation = performance.getEntriesByType('navigation')[0];
+    if (navigation) {
+        metrics.ttfb = navigation.responseStart - navigation.requestStart;
+        metrics.domReady = navigation.domContentLoadedEventEnd - navigation.startTime;
+        metrics.loadComplete = navigation.loadEventEnd - navigation.startTime;
+    }
+    // 获取 FP 和 FCP
+    const paintEntries = performance.getEntriesByType('paint');
+    for (const entry of paintEntries) {
+        if (entry.name === 'first-paint') {
+            metrics.fp = entry.startTime;
+        }
+        if (entry.name === 'first-contentful-paint') {
+            metrics.fcp = entry.startTime;
+        }
+    }
+    // 获取 LCP
+    collectLCP(metrics);
+    // 获取 FID
+    collectFID(metrics);
+    // 获取 CLS
+    collectCLS(metrics);
+    // 上报性能数据
+    reporter.reportPerformance({
+        type: 'performance',
+        metrics,
+    });
+}
+/**
+ * 采集 LCP (Largest Contentful Paint)
+ */
+function collectLCP(metrics) {
+    if (!('PerformanceObserver' in window))
+        return;
+    try {
+        const observer = new PerformanceObserver((list) => {
+            const entries = list.getEntries();
+            const lastEntry = entries[entries.length - 1];
+            if (lastEntry) {
+                metrics.lcp = lastEntry.startTime;
+            }
+        });
+        observer.observe({ type: 'largest-contentful-paint', buffered: true });
+    }
+    catch (e) {
+        // 浏览器不支持
+    }
+}
+/**
+ * 采集 FID (First Input Delay)
+ */
+function collectFID(metrics) {
+    if (!('PerformanceObserver' in window))
+        return;
+    try {
+        const observer = new PerformanceObserver((list) => {
+            const entries = list.getEntries();
+            const firstEntry = entries[0];
+            if (firstEntry) {
+                metrics.fid = firstEntry.processingStart - firstEntry.startTime;
+            }
+        });
+        observer.observe({ type: 'first-input', buffered: true });
+    }
+    catch (e) {
+        // 浏览器不支持
+    }
+}
+/**
+ * 采集 CLS (Cumulative Layout Shift)
+ */
+function collectCLS(metrics) {
+    if (!('PerformanceObserver' in window))
+        return;
+    let clsValue = 0;
+    try {
+        const observer = new PerformanceObserver((list) => {
+            const entries = list.getEntries();
+            for (const entry of entries) {
+                if (!entry.hadRecentInput) {
+                    clsValue += entry.value;
+                }
+            }
+            metrics.cls = clsValue;
+        });
+        observer.observe({ type: 'layout-shift', buffered: true });
+    }
+    catch (e) {
+        // 浏览器不支持
+    }
+}
+
+/**
+ * 性能监控插件入口
+ */
+/**
+ * 安装性能监控
+ */
+function installPerformanceMonitor() {
+    installWebVitals();
+}
+
+/**
+ * PV (Page View) 统计插件
+ */
+/**
+ * 安装 PV 统计
+ */
+function installPVTracker() {
+    const cfg = config.get();
+    if (!cfg.behavior?.enabled || !cfg.behavior?.pv) {
+        return;
+    }
+    // 页面加载时上报
+    reportPV();
+    if (cfg.debug) {
+        console.log('[Monitor] PV tracker installed');
+    }
+}
+/**
+ * 上报 PV
+ */
+function reportPV() {
+    reporter.reportBehavior({
+        type: 'behavior',
+        action: 'pv',
+        data: {
+            title: getPageTitle(),
+            referrer: getReferrer(),
+        },
+    });
+}
+
+/**
+ * 点击事件追踪插件
+ */
+/**
+ * 安装点击追踪
+ */
+function installClickTracker() {
+    const cfg = config.get();
+    if (!cfg.behavior?.enabled || !cfg.behavior?.click) {
+        return;
+    }
+    document.addEventListener('click', (event) => {
+        const target = event.target;
+        if (!target)
+            return;
+        const clickData = extractClickData(target, event);
+        // 添加到面包屑
+        context.addBreadcrumb({
+            type: 'click',
+            category: 'ui.click',
+            data: clickData,
+        });
+        // 可选：上报点击事件（一般只记录面包屑，不单独上报）
+        // reporter.reportBehavior({
+        //   type: 'behavior',
+        //   action: 'click',
+        //   data: clickData,
+        // });
+    }, true);
+    if (cfg.debug) {
+        console.log('[Monitor] Click tracker installed');
+    }
+}
+/**
+ * 提取点击数据
+ */
+function extractClickData(element, event) {
+    const tagName = element.tagName.toLowerCase();
+    const rect = element.getBoundingClientRect();
+    return {
+        tagName,
+        id: element.id || undefined,
+        className: element.className || undefined,
+        text: getElementText(element),
+        path: getElementPath(element),
+        // 鼠标坐标
+        x: event.clientX,
+        y: event.clientY,
+        // 元素位置和尺寸
+        rect: {
+            top: Math.round(rect.top),
+            left: Math.round(rect.left),
+            width: Math.round(rect.width),
+            height: Math.round(rect.height),
+        },
+        // 额外属性
+        href: element.href || undefined,
+        name: element.name || undefined,
+        type: element.type || undefined,
+    };
+}
+/**
+ * 获取元素文本（限制长度）
+ */
+function getElementText(element) {
+    const text = element.innerText || element.textContent || '';
+    return text.trim().substring(0, 50);
+}
+/**
+ * 获取元素路径
+ */
+function getElementPath(element) {
+    const path = [];
+    let current = element;
+    while (current && path.length < 5) {
+        let selector = current.tagName.toLowerCase();
+        if (current.id) {
+            selector += `#${current.id}`;
+        }
+        else if (current.className) {
+            const classes = current.className.split(' ').filter(Boolean).slice(0, 2);
+            if (classes.length) {
+                selector += `.${classes.join('.')}`;
+            }
+        }
+        path.unshift(selector);
+        current = current.parentElement;
+    }
+    return path.join(' > ');
+}
+
+/**
+ * 路由变化监控插件
+ * 支持 History API 和 Hash 路由
+ */
+// 保存原始方法
+const originalPushState = history.pushState;
+const originalReplaceState = history.replaceState;
+/**
+ * 安装路由监控
+ */
+function installRouteTracker() {
+    const cfg = config.get();
+    if (!cfg.behavior?.enabled || !cfg.behavior?.route) {
+        return;
+    }
+    // 拦截 pushState
+    history.pushState = function (...args) {
+        const result = originalPushState.apply(this, args);
+        handleRouteChange('pushState');
+        return result;
+    };
+    // 拦截 replaceState
+    history.replaceState = function (...args) {
+        const result = originalReplaceState.apply(this, args);
+        handleRouteChange('replaceState');
+        return result;
+    };
+    // 监听 popstate（浏览器前进后退）
+    window.addEventListener('popstate', () => {
+        handleRouteChange('popstate');
+    });
+    // 监听 hashchange
+    window.addEventListener('hashchange', () => {
+        handleRouteChange('hashchange');
+    });
+    if (cfg.debug) {
+        console.log('[Monitor] Route tracker installed');
+    }
+}
+/**
+ * 处理路由变化
+ */
+function handleRouteChange(trigger) {
+    const routeData = {
+        url: getPageUrl(),
+        title: getPageTitle(),
+        trigger,
+    };
+    // 添加到面包屑
+    context.addBreadcrumb({
+        type: 'route',
+        category: 'navigation',
+        data: routeData,
+    });
+    // 上报路由变化
+    reporter.reportBehavior({
+        type: 'behavior',
+        action: 'route',
+        data: routeData,
+    });
+}
+
+/**
+ * 控制台日志追踪插件
+ * 追踪 console.log/warn/error/info 调用
+ */
+// 保存原始方法
+const originalConsole = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error,
+};
+/**
+ * 安装控制台追踪
+ */
+function installConsoleTracker() {
+    const cfg = config.get();
+    // 默认启用控制台追踪（跟随 behavior.enabled）
+    if (!cfg.behavior?.enabled) {
+        return;
+    }
+    const levels = ['log', 'info', 'warn', 'error'];
+    levels.forEach((level) => {
+        console[level] = function (...args) {
+            // 调用原始方法
+            originalConsole[level].apply(console, args);
+            // 添加到面包屑（只记录 warn 和 error）
+            if (level === 'warn' || level === 'error') {
+                const message = formatConsoleArgs(args);
+                context.addBreadcrumb({
+                    type: 'console',
+                    category: `console.${level}`,
+                    data: {
+                        level,
+                        message: message.substring(0, 200), // 限制长度
+                    },
+                });
+            }
+        };
+    });
+    if (cfg.debug) {
+        originalConsole.log('[Monitor] Console tracker installed');
+    }
+}
+/**
+ * 格式化控制台参数
+ */
+function formatConsoleArgs(args) {
+    return args
+        .map((arg) => {
+        if (typeof arg === 'string') {
+            return arg;
+        }
+        if (arg instanceof Error) {
+            return arg.message;
+        }
+        try {
+            return JSON.stringify(arg);
+        }
+        catch {
+            return String(arg);
+        }
+    })
+        .join(' ');
+}
+
+/**
+ * 输入事件追踪插件
+ * 追踪表单输入、焦点变化等
+ */
+/**
+ * 安装输入追踪
+ */
+function installInputTracker() {
+    const cfg = config.get();
+    // 默认启用输入追踪（跟随 behavior.enabled）
+    if (!cfg.behavior?.enabled) {
+        return;
+    }
+    // 监听 input 事件（使用 change 事件减少数据量）
+    document.addEventListener('change', handleInputChange, true);
+    // 监听焦点事件
+    document.addEventListener('focus', handleFocus, true);
+    document.addEventListener('blur', handleBlur, true);
+    if (cfg.debug) {
+        console.log('[Monitor] Input tracker installed');
+    }
+}
+/**
+ * 处理输入变化
+ */
+function handleInputChange(event) {
+    const target = event.target;
+    if (!target || !isFormElement(target))
+        return;
+    const inputData = extractInputData(target, 'change');
+    context.addBreadcrumb({
+        type: 'input',
+        category: 'ui.input',
+        data: inputData,
+    });
+}
+/**
+ * 处理焦点获取
+ */
+function handleFocus(event) {
+    const target = event.target;
+    if (!target || !isFormElement(target))
+        return;
+    context.addBreadcrumb({
+        type: 'input',
+        category: 'ui.focus',
+        data: extractInputData(target, 'focus'),
+    });
+}
+/**
+ * 处理焦点失去
+ */
+function handleBlur(event) {
+    const target = event.target;
+    if (!target || !isFormElement(target))
+        return;
+    context.addBreadcrumb({
+        type: 'input',
+        category: 'ui.blur',
+        data: extractInputData(target, 'blur'),
+    });
+}
+/**
+ * 判断是否是表单元素
+ */
+function isFormElement(element) {
+    const tagName = element.tagName.toLowerCase();
+    return ['input', 'textarea', 'select'].includes(tagName);
+}
+/**
+ * 提取输入数据（脱敏处理）
+ */
+function extractInputData(element, action) {
+    const tagName = element.tagName.toLowerCase();
+    const inputType = element.type || 'text';
+    // 敏感类型不记录值
+    const sensitiveTypes = ['password', 'credit-card', 'cvv'];
+    sensitiveTypes.includes(inputType) ||
+        element.name?.toLowerCase().includes('password') ||
+        element.name?.toLowerCase().includes('secret');
+    return {
+        action,
+        tagName,
+        name: element.name || undefined,
+        id: element.id || undefined,
+        type: inputType,
+        // 脱敏：敏感字段不记录值，其他字段只记录长度
+        valueLength: element.value?.length || 0,
+        hasValue: !!element.value,
+        placeholder: element.placeholder || undefined,
+    };
+}
+
+/**
+ * 行为监控插件入口
+ */
+/**
+ * 安装行为监控
+ */
+function installBehaviorMonitor() {
+    installPVTracker();
+    installClickTracker();
+    installRouteTracker();
+    installConsoleTracker();
+    installInputTracker();
+}
+
+/**
+ * 前端监控 SDK
+ * @description 错误监控、性能监控、行为监控
+ */
+// SDK 版本
+const SDK_VERSION = '1.0.0';
+/**
+ * 监控 SDK 主类
+ */
+class MonitorSDK {
+    constructor() {
+        this.initialized = false;
+    }
+    /**
+     * 初始化 SDK
+     */
+    init(userConfig) {
+        if (this.initialized) {
+            console.warn('[Monitor] SDK already initialized');
+            return;
+        }
+        // 初始化配置
+        config.init({
+            ...userConfig,
+            version: userConfig.version || SDK_VERSION,
+        });
+        // 初始化上下文
+        const maxBreadcrumbs = config.get().behavior?.maxBreadcrumbs || 20;
+        context.init(maxBreadcrumbs);
+        this.initialized = true;
+        if (config.get().debug) {
+            console.log('[Monitor] SDK initialized', config.get());
+        }
+        // 安装监控模块
+        installErrorHandlers();
+        installPerformanceMonitor();
+        installBehaviorMonitor();
+    }
+    /**
+     * 设置用户信息
+     */
+    setUser(user) {
+        this.checkInit();
+        config.setUser(user);
+    }
+    /**
+     * 手动上报错误
+     */
+    captureError(error, extra) {
+        this.checkInit();
+        const errorData = {
+            type: 'js_error',
+            message: typeof error === 'string' ? error : error.message,
+            stack: typeof error === 'string' ? undefined : error.stack,
+            ...extra,
+        };
+        reporter.reportError(errorData);
+    }
+    /**
+     * 手动上报性能数据
+     */
+    capturePerformance(metrics) {
+        this.checkInit();
+        reporter.reportPerformance({
+            type: 'performance',
+            metrics,
+        });
+    }
+    /**
+     * 手动上报行为数据
+     */
+    captureBehavior(action, data) {
+        this.checkInit();
+        reporter.reportBehavior({
+            type: 'behavior',
+            action,
+            data,
+        });
+    }
+    /**
+     * 添加面包屑
+     */
+    addBreadcrumb(crumb) {
+        this.checkInit();
+        context.addBreadcrumb(crumb);
+    }
+    /**
+     * 立即发送缓冲区数据
+     */
+    flush() {
+        this.checkInit();
+        reporter.flush();
+    }
+    /**
+     * 获取 SDK 版本
+     */
+    getVersion() {
+        return SDK_VERSION;
+    }
+    /**
+     * 检查是否已初始化
+     */
+    checkInit() {
+        if (!this.initialized) {
+            throw new Error('[Monitor] SDK not initialized. Please call init() first.');
+        }
+    }
+}
+// 导出单例
+const monitor = new MonitorSDK();
+
+exports.default = monitor;
+exports.monitor = monitor;
+//# sourceMappingURL=index.cjs.js.map