befly-shared 2.12.0 → 2.14.0

package/internal/reportUtil.js

@@ -0,0 +1,86 @@
+import { createHttp } from "../utils/createHttp.js";
+
+async function returnPayload(payload) {
+    return payload;
+}
+
+export function assertReportRequest(options, operation) {
+    if (!options || (typeof options.request !== "function" && typeof options.apiPath !== "string")) {
+        throw new Error(`${operation}.options 必须提供 request 函数或 apiPath 字符串`, {
+            cause: null,
+            code: "validation",
+            subsystem: "shared",
+            operation: operation
+        });
+    }
+}
+
+export function getReportRequest(options, operation) {
+    assertReportRequest(options, operation);
+
+    if (typeof options.request === "function") {
+        return options.request;
+    }
+
+    return createHttp({
+        apiPath: options.apiPath,
+        getToken: typeof options.getToken === "function" ? options.getToken : () => "",
+        onReturn: typeof options.onReturn === "function" ? options.onReturn : returnPayload
+    });
+}
+
+export function copyReportData(target, source) {
+    if (!source || typeof source !== "object") {
+        return;
+    }
+
+    for (const key of Object.keys(source)) {
+        if (source[key] !== undefined) {
+            target[key] = source[key];
+        }
+    }
+}
+
+export function createCommonReportData(options) {
+    return {
+        source: options.source || "",
+        productName: options.productName || "",
+        productCode: options.productCode || "",
+        productVersion: options.productVersion || ""
+    };
+}
+
+export function appendPageAndExtraData(data, options, extraData) {
+    if (typeof options.getPageData === "function") {
+        copyReportData(data, options.getPageData());
+    }
+
+    copyReportData(data, extraData);
+    return data;
+}
+
+export function getRouteReportData(route) {
+    return {
+        pagePath: route?.fullPath || route?.path || "",
+        pageName: String(route?.name || route?.meta?.title || route?.path || "")
+    };
+}
+
+export function getCurrentRouterData(router) {
+    const currentRoute = router?.currentRoute?.value || {};
+    let fallbackPath = "";
+    let fallbackTitle = "";
+
+    if (typeof globalThis.window !== "undefined") {
+        fallbackPath = globalThis.window.location.hash || globalThis.window.location.pathname || "";
+    }
+
+    if (typeof globalThis.document !== "undefined") {
+        fallbackTitle = globalThis.document.title || "";
+    }
+
+    return {
+        pagePath: String(currentRoute.fullPath || currentRoute.path || fallbackPath),
+        pageName: String(currentRoute.name || currentRoute.meta?.title || currentRoute.path || fallbackTitle)
+    };
+}

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "befly-shared",
-    "version": "2.12.0",
+    "version": "2.14.0",
     "gitHead": "70c48ac058875255ac8b54c5f4b5987b997c3bfd",
     "private": false,
     "description": "Befly Shared - 通用工具函数库",
     "files": [
         "utils/",
+        "internal/",
         "package.json"
     ],
     "type": "module",

package/utils/createHttp.js

@@ -2,7 +2,7 @@ export function createHttp(options) {
     const request = async function (url, data, dropValues = [], dropKeyValue = {}) {
         try {
             const fullUrl = /^https?:\/\//i.test(url) ? url : `${options.apiPath}${url}`;
-            const isForm = data instanceof FormData;
+            const isForm = typeof FormData !== "undefined" && data instanceof FormData;
             const dropList = [null, undefined, ...dropValues];
             const dropKeyMap = {
                 ...dropKeyValue,

package/utils/errorReport.js

@@ -0,0 +1,282 @@
+import { appendPageAndExtraData, createCommonReportData, getReportRequest } from "../internal/reportUtil.js";
+
+const ERROR_REPORT_PATH = "/core/tongJi/errorReport";
+const ERROR_REPORT_DEDUP_GAP = 3000;
+let fetchWrapped = false;
+
+function buildReportData(options, errorType, message, detail, extraData) {
+    const data = createCommonReportData(options);
+    data.errorType = String(errorType || "unknown");
+    data.message = String(message || "未知错误");
+    data.detail = String(detail || "");
+
+    return appendPageAndExtraData(data, options, extraData);
+}
+
+export function getErrorMessage(error) {
+    if (typeof error === "string") {
+        return error;
+    }
+
+    if (error && typeof error.message === "string") {
+        return error.message;
+    }
+
+    return "未知错误";
+}
+
+export function getErrorDetail(error) {
+    if (!error) {
+        return "";
+    }
+
+    if (typeof error === "string") {
+        return error;
+    }
+
+    if (typeof error.stack === "string" && error.stack) {
+        return error.stack;
+    }
+
+    try {
+        return JSON.stringify(error);
+    } catch {
+        return String(error);
+    }
+}
+
+export function createErrorReport(options) {
+    const request = getReportRequest(options, "createErrorReport");
+
+    let reporting = false;
+    let lastErrorKey = "";
+    let lastErrorTime = 0;
+
+    function shouldSkipError(errorType, message, detail) {
+        const now = Date.now();
+        const key = `${errorType}|${message}|${detail}`;
+
+        if (key === lastErrorKey && now - lastErrorTime < ERROR_REPORT_DEDUP_GAP) {
+            return true;
+        }
+
+        lastErrorKey = key;
+        lastErrorTime = now;
+        return false;
+    }
+
+    return {
+        reportError: async function (errorType, message, detail, extraData = {}) {
+            const safeErrorType = String(errorType || "unknown");
+            const safeMessage = String(message || "未知错误");
+            const safeDetail = String(detail || "");
+
+            if (shouldSkipError(safeErrorType, safeMessage, safeDetail)) {
+                return false;
+            }
+
+            if (reporting) {
+                return false;
+            }
+
+            reporting = true;
+
+            try {
+                await request(ERROR_REPORT_PATH, buildReportData(options, safeErrorType, safeMessage, safeDetail, extraData));
+                return true;
+            } catch {
+                return false;
+            } finally {
+                reporting = false;
+            }
+        }
+    };
+}
+
+export function setupErrorReport(options) {
+    const errorReporter = createErrorReport(options);
+
+    function reportClientError(errorType, message, detail) {
+        void errorReporter.reportError(errorType, message, detail);
+    }
+
+    if (options.reportHttp !== false) {
+        setupFetchErrorReport(options, reportClientError);
+    }
+
+    if (options.app?.config && options.reportVue !== false) {
+        options.app.config.errorHandler = (error, _instance, info) => {
+            const message = getErrorMessage(error);
+            const detail = `${String(info || "")}${info ? "\n" : ""}${getErrorDetail(error)}`;
+
+            reportClientError("vue", message, detail);
+        };
+    }
+
+    if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+        if (options.reportWindow !== false) {
+            window.addEventListener(
+                "error",
+                (event) => {
+                    const target = event.target;
+
+                    if (target && target !== window) {
+                        if (options.reportResource === false) {
+                            return;
+                        }
+
+                        const resourceName = target.tagName ? `${String(target.tagName).toLowerCase()} 资源加载失败` : "资源加载失败";
+                        const parts = [];
+
+                        if (target?.tagName) {
+                            parts.push(`tag: ${String(target.tagName).toLowerCase()}`);
+                        }
+
+                        if (target?.src) {
+                            parts.push(`src: ${target.src}`);
+                        }
+
+                        if (target?.href) {
+                            parts.push(`href: ${target.href}`);
+                        }
+
+                        reportClientError("resource", resourceName, parts.join("\n"));
+                        return;
+                    }
+
+                    const parts = [];
+
+                    if (event.filename) {
+                        parts.push(`file: ${event.filename}`);
+                    }
+
+                    if (event.lineno || event.colno) {
+                        parts.push(`line: ${event.lineno || 0}, col: ${event.colno || 0}`);
+                    }
+
+                    const stack = getErrorDetail(event.error);
+
+                    if (stack) {
+                        parts.push(stack);
+                    }
+
+                    reportClientError("window", getErrorMessage(event.message || event.error), parts.join("\n"));
+                },
+                true
+            );
+        }
+
+        if (options.reportPromise !== false) {
+            window.addEventListener("unhandledrejection", (event) => {
+                const reason = event.reason;
+
+                reportClientError("promise", getErrorMessage(reason), getErrorDetail(reason));
+            });
+        }
+    }
+
+    if (options.router && typeof options.router.onError === "function" && options.reportRouter !== false) {
+        options.router.onError((error) => {
+            reportClientError("router", getErrorMessage(error), getErrorDetail(error));
+        });
+    }
+
+    return {
+        reporter: errorReporter,
+        reportClientError: reportClientError
+    };
+}
+
+function setupFetchErrorReport(options, reportClientError) {
+    if (fetchWrapped) {
+        return;
+    }
+
+    if (typeof window === "undefined" || typeof window.fetch !== "function") {
+        return;
+    }
+
+    const originalFetch = window.fetch.bind(window);
+
+    window.fetch = async (...args) => {
+        const input = args[0];
+        const url = typeof input === "string" ? input : input && typeof input.url === "string" ? input.url : "";
+        const apiPath = String(options.apiPath || "");
+        const isApiRequest = Boolean(apiPath) && String(url || "").startsWith(apiPath);
+        const isErrorReportRequest = String(url || "").includes("/core/tongJi/errorReport");
+
+        try {
+            const response = await originalFetch(...args);
+
+            if (isApiRequest && !isErrorReportRequest) {
+                if (!response.ok) {
+                    const parts = [];
+
+                    if (url) {
+                        parts.push(`url: ${url}`);
+                    }
+
+                    if (response.status) {
+                        parts.push(`status: ${response.status}`);
+                    }
+
+                    reportClientError("http", `请求失败：HTTP ${response.status}`, parts.join("\n"));
+                } else {
+                    try {
+                        const payload = await response.clone().json();
+
+                        if (payload?.code !== 0) {
+                            const parts = [];
+
+                            if (url) {
+                                parts.push(`url: ${url}`);
+                            }
+
+                            if (response.status) {
+                                parts.push(`status: ${response.status}`);
+                            }
+
+                            if (payload?.code !== undefined) {
+                                parts.push(`code: ${payload.code}`);
+                            }
+
+                            if (payload?.msg) {
+                                parts.push(`msg: ${payload.msg}`);
+                            }
+
+                            if (payload?.detail) {
+                                parts.push(`detail: ${payload.detail}`);
+                            }
+
+                            reportClientError("http", payload.msg || "请求失败", parts.join("\n"));
+                        }
+                    } catch {
+                        // ignore
+                    }
+                }
+            }
+
+            return response;
+        } catch (error) {
+            if (isApiRequest && !isErrorReportRequest) {
+                const parts = [];
+
+                if (url) {
+                    parts.push(`url: ${url}`);
+                }
+
+                const errorDetail = getErrorDetail(error);
+
+                if (errorDetail) {
+                    parts.push(`detail: ${errorDetail}`);
+                }
+
+                reportClientError("http", getErrorMessage(error), parts.join("\n"));
+            }
+
+            throw error;
+        }
+    };
+
+    fetchWrapped = true;
+}

package/utils/infoReport.js

@@ -0,0 +1,31 @@
+import { appendPageAndExtraData, createCommonReportData, getReportRequest, getRouteReportData } from "../internal/reportUtil.js";
+
+const INFO_REPORT_PATH = "/core/tongJi/infoReport";
+
+function buildReportData(options, extraData) {
+    return appendPageAndExtraData(createCommonReportData(options), options, extraData);
+}
+
+export function createInfoReport(options) {
+    const request = getReportRequest(options, "createInfoReport");
+
+    return {
+        reportInfo: function (extraData = {}) {
+            return request(INFO_REPORT_PATH, buildReportData(options, extraData));
+        }
+    };
+}
+
+export function setupInfoReport(options) {
+    const infoReporter = createInfoReport(options);
+
+    if (options.router && typeof options.router.afterEach === "function") {
+        options.router.afterEach((to) => {
+            void infoReporter.reportInfo(getRouteReportData(to)).catch(() => {
+                // ignore
+            });
+        });
+    }
+
+    return infoReporter;
+}

package/utils/onlineReport.js

@@ -0,0 +1,155 @@
+import { appendPageAndExtraData, createCommonReportData, getReportRequest } from "../internal/reportUtil.js";
+
+const ONLINE_REPORT_PATH = "/core/tongJi/onlineReport";
+const ONLINE_REPORT_MIN_GAP = 15 * 1000;
+const ONLINE_REPORT_HEARTBEAT_INTERVAL = 60 * 1000;
+const ONLINE_REPORT_CLIENT_ID_KEY = "befly-online-client-id";
+
+function generateOnlineClientId() {
+    return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function readStoredClientId(storageKey) {
+    if (typeof globalThis.localStorage === "undefined") {
+        return "";
+    }
+
+    try {
+        return String(globalThis.localStorage.getItem(storageKey) || "").trim();
+    } catch {
+        return "";
+    }
+}
+
+function writeStoredClientId(storageKey, clientId) {
+    if (typeof globalThis.localStorage === "undefined") {
+        return;
+    }
+
+    try {
+        globalThis.localStorage.setItem(storageKey, clientId);
+    } catch {
+        // ignore
+    }
+}
+
+function buildReportData(options, clientId, extraData) {
+    const data = createCommonReportData(options);
+    data.clientId = clientId;
+
+    return appendPageAndExtraData(data, options, extraData);
+}
+
+function isDocumentActive() {
+    if (typeof document !== "undefined" && document.visibilityState !== "visible") {
+        return false;
+    }
+
+    return true;
+}
+
+export function createOnlineReport(options) {
+    const request = getReportRequest(options, "createOnlineReport");
+
+    let heartbeatStarted = false;
+    let lastReportTime = 0;
+    let timeoutId = 0;
+
+    function getClientId() {
+        if (typeof options.getClientId === "function") {
+            return String(options.getClientId() || "");
+        }
+
+        const storedClientId = readStoredClientId(ONLINE_REPORT_CLIENT_ID_KEY);
+        if (storedClientId) {
+            return storedClientId;
+        }
+
+        const clientId = generateOnlineClientId();
+        writeStoredClientId(ONLINE_REPORT_CLIENT_ID_KEY, clientId);
+        return clientId;
+    }
+
+    function clearHeartbeatTimer() {
+        if (!timeoutId || typeof globalThis.clearTimeout !== "function") {
+            timeoutId = 0;
+            return;
+        }
+
+        globalThis.clearTimeout(timeoutId);
+        timeoutId = 0;
+    }
+
+    function queueHeartbeat() {
+        if (typeof globalThis.setTimeout !== "function") {
+            return;
+        }
+
+        clearHeartbeatTimer();
+
+        timeoutId = globalThis.setTimeout(() => {
+            void triggerOnlineReport();
+            queueHeartbeat();
+        }, ONLINE_REPORT_HEARTBEAT_INTERVAL);
+    }
+
+    async function reportOnline(extraData = {}) {
+        lastReportTime = Date.now();
+        return request(ONLINE_REPORT_PATH, buildReportData(options, getClientId(), extraData));
+    }
+
+    async function triggerOnlineReport(force = false, extraData = {}) {
+        if (!isDocumentActive()) {
+            return false;
+        }
+
+        const now = Date.now();
+
+        if (!force && now - lastReportTime < ONLINE_REPORT_MIN_GAP) {
+            return false;
+        }
+
+        try {
+            await reportOnline(extraData);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    function startHeartbeat() {
+        if (heartbeatStarted) {
+            return;
+        }
+
+        heartbeatStarted = true;
+
+        if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+            window.addEventListener("focus", () => {
+                void triggerOnlineReport();
+            });
+        }
+
+        if (typeof document !== "undefined" && typeof document.addEventListener === "function") {
+            document.addEventListener("visibilitychange", () => {
+                void triggerOnlineReport();
+            });
+        }
+
+        void triggerOnlineReport(true);
+        queueHeartbeat();
+    }
+
+    return {
+        reportOnline: reportOnline,
+        startHeartbeat: startHeartbeat
+    };
+}
+
+export function setupOnlineReport(options) {
+    const onlineReporter = createOnlineReport(options);
+
+    onlineReporter.startHeartbeat();
+
+    return onlineReporter;
+}