@pluve/mp-logger-sdk 0.0.1

package/dist/esm/core/retryManager.js

@@ -0,0 +1,103 @@
+// src/core/retryManager.ts
+import { logDebug } from "../utils/tools";
+var RetryManager = class {
+  constructor(options) {
+    this.retryingTasks = /* @__PURE__ */ new Map();
+    this.opts = options;
+  }
+  /**
+   * 执行带重试的任务
+   * @param taskId - 任务唯一标识
+   * @param fn - 要执行的异步函数
+   * @returns Promise
+   */
+  async executeWithRetry(taskId, fn) {
+    if (this.retryingTasks.has(taskId)) {
+      logDebug(!!this.opts.debug, `Task ${taskId} already retrying, skipped`);
+      throw new Error(`Task ${taskId} already retrying`);
+    }
+    const task = {
+      id: taskId,
+      fn,
+      retries: 0,
+      maxRetries: this.opts.maxRetries,
+      baseDelay: this.opts.baseDelay,
+      useBackoff: this.opts.useBackoff
+    };
+    this.retryingTasks.set(taskId, task);
+    try {
+      const result = await this.executeTask(task);
+      this.retryingTasks.delete(taskId);
+      return result;
+    } catch (error) {
+      this.retryingTasks.delete(taskId);
+      throw error;
+    }
+  }
+  /**
+   * 执行任务（带重试逻辑）
+   */
+  async executeTask(task) {
+    while (task.retries <= task.maxRetries) {
+      try {
+        const result = await task.fn();
+        if (task.retries > 0) {
+          logDebug(!!this.opts.debug, `Task ${task.id} succeeded after ${task.retries} retries`);
+        }
+        return result;
+      } catch (error) {
+        task.retries += 1;
+        if (task.retries > task.maxRetries) {
+          logDebug(!!this.opts.debug, `Task ${task.id} failed after ${task.maxRetries} retries`);
+          throw error;
+        }
+        const delay = RetryManager.calculateDelay(task.retries, task.baseDelay, task.useBackoff);
+        logDebug(
+          !!this.opts.debug,
+          `Task ${task.id} failed (attempt ${task.retries}/${task.maxRetries}), retrying in ${delay}ms`
+        );
+        await RetryManager.sleep(delay);
+      }
+    }
+    throw new Error(`Task ${task.id} exceeded max retries`);
+  }
+  /**
+   * 计算延迟时间
+   * @param attempt - 当前重试次数
+   * @param baseDelay - 基础延迟时间
+   * @param useBackoff - 是否使用指数退避
+   * @returns 延迟时间（毫秒）
+   */
+  static calculateDelay(attempt, baseDelay, useBackoff) {
+    if (!useBackoff) {
+      return baseDelay;
+    }
+    const factor = 2 ** (attempt - 1);
+    const delay = baseDelay * factor;
+    const jitterRatio = 0.3;
+    const maxDelay = 3e4;
+    const jitter = Math.random() * jitterRatio * delay;
+    return Math.min(delay + jitter, maxDelay);
+  }
+  /**
+   * 睡眠函数
+   */
+  static sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 获取正在重试的任务数量
+   */
+  getRetryingCount() {
+    return this.retryingTasks.size;
+  }
+  /**
+   * 清空所有重试任务
+   */
+  clear() {
+    this.retryingTasks.clear();
+  }
+};
+export {
+  RetryManager
+};

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+// src/index.ts
+import { LoggerSDK } from "./core/loggerSDK";
+export {
+  LoggerSDK
+};

package/dist/esm/stack/stacktrace.js

@@ -0,0 +1,49 @@
+// src/stack/stacktrace.ts
+function parseErrorStack(stack) {
+  const lines = stack.split("\n");
+  const frames = [];
+  lines.forEach((line) => {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return;
+    if (trimmed.startsWith("Error:"))
+      return;
+    const v8Match = trimmed.match(/^at (?:(.+?)\s+\()?(?:(.+?):(\d+):(\d+))\)?$/);
+    if (v8Match) {
+      frames.push({
+        function: v8Match[1] || void 0,
+        file: v8Match[2],
+        line: parseInt(v8Match[3], 10),
+        column: parseInt(v8Match[4], 10)
+      });
+      return;
+    }
+    const jscMatch = trimmed.match(/^(?:(.+?)@)?(.+?):(\d+):(\d+)$/);
+    if (jscMatch) {
+      frames.push({
+        function: jscMatch[1] || void 0,
+        file: jscMatch[2],
+        line: parseInt(jscMatch[3], 10),
+        column: parseInt(jscMatch[4], 10)
+      });
+    }
+  });
+  return frames;
+}
+async function parseStack(error) {
+  return new Promise((resolve) => {
+    try {
+      if (!error || !error.stack) {
+        resolve([]);
+        return;
+      }
+      const frames = parseErrorStack(error.stack);
+      resolve(frames.slice(0, 5));
+    } catch (e) {
+      resolve([]);
+    }
+  });
+}
+export {
+  parseStack
+};

package/dist/esm/transport/transportAdapter.js

@@ -0,0 +1,19 @@
+// src/transport/transportAdapter.ts
+import { WechatTransport } from "./wechatTransport";
+var TransportAdapter = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  static getInstance(opts) {
+    if (!TransportAdapter.instance) {
+      TransportAdapter.instance = new TransportAdapter(opts);
+    }
+    return TransportAdapter.instance;
+  }
+  async getTransporter() {
+    return new WechatTransport(this.opts);
+  }
+};
+export {
+  TransportAdapter
+};

package/dist/esm/transport/wechatTransport.js

@@ -0,0 +1,78 @@
+// src/transport/wechatTransport.ts
+import { gzipCompress } from "../compress/compression";
+import { getReportApi } from "../config";
+import { logDebug, now, safeStringify } from "../utils/tools";
+var WechatTransport = class {
+  constructor(opts) {
+    /** 传输器名称 */
+    this.name = "wechat";
+    this.opts = opts;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  isSupported() {
+    return true;
+  }
+  async send(token, payload) {
+    var _a, _b, _c, _d, _e;
+    let body = typeof payload === "string" ? payload : safeStringify(payload);
+    const endpoint = `${getReportApi(((_a = this.opts) == null ? void 0 : _a.env) || "develop")}?token=${token}`;
+    const timeout = 1e4;
+    let contentType = "application/json";
+    if (((_b = this.opts) == null ? void 0 : _b.enableGzip) && payload.items.length >= ((_c = this.opts) == null ? void 0 : _c.gzipBatchMinSize)) {
+      const t = now();
+      logDebug(!!((_d = this.opts) == null ? void 0 : _d.debug), "WeChat request enable gzip compress: ", t);
+      const compressedItems = await gzipCompress(safeStringify(payload.items));
+      body = safeStringify({
+        ...payload,
+        items: compressedItems
+      });
+      logDebug(!!((_e = this.opts) == null ? void 0 : _e.debug), "WeChat request gzip compress cost: ", now() - t);
+      contentType = "application/json; charset=utf-8";
+    }
+    return new Promise((resolve, reject) => {
+      var _a2;
+      let timeoutId = null;
+      let settled = false;
+      timeoutId = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          reject(new Error(`WeChat request timeout after ${timeout}ms`));
+        }
+      }, timeout);
+      wx.request({
+        url: endpoint,
+        method: "POST",
+        data: body,
+        header: {
+          "Content-Type": contentType,
+          token: ((_a2 = this.opts) == null ? void 0 : _a2.token) || ""
+        },
+        success(res) {
+          if (timeoutId)
+            clearTimeout(timeoutId);
+          if (!settled) {
+            settled = true;
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+              resolve();
+            } else {
+              reject(new Error(`HTTP ${res.statusCode}`));
+            }
+          }
+        },
+        fail(err) {
+          var _a3;
+          if (timeoutId)
+            clearTimeout(timeoutId);
+          if (!settled) {
+            settled = true;
+            logDebug(!!((_a3 = this.opts) == null ? void 0 : _a3.debug), "WeChat request failed", err);
+            reject(new Error(`WeChat request failed: ${err.errMsg || "unknown error"}`));
+          }
+        }
+      });
+    });
+  }
+};
+export {
+  WechatTransport
+};

package/dist/esm/types/external.d.ts

@@ -0,0 +1,15 @@
+/*
+ * @Author: 黄震 huangzhen@yfpharmacy.com
+ * @Date: 2026-02-03 10:26:04
+ * @LastEditors: 黄震 huangzhen@yfpharmacy.com
+ * @LastEditTime: 2026-02-13 15:15:07
+ * @FilePath: /pluve-lib/packages/mp-logger-sdk/src/types/external.d.ts
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
+declare module 'fflate' {
+  export function gzipSync(input: Uint8Array | string): Uint8Array;
+}
+
+declare const wx: any;
+declare function getCurrentPages(): any[];
+

package/dist/esm/types/securityType.js

@@ -0,0 +1,14 @@
+// src/types/securityType.ts
+var SecurityType = {
+  ACCOUNT_CENTER: "2B",
+  // 2B（账号中心）
+  EHP: "EHP",
+  // EHP（医疗）
+  CUSTOMER: "CUSTOMER",
+  // 2C（会员，这期不涉及先预留）
+  BASE: "BASE"
+  // BASE（兜底MD5）
+};
+export {
+  SecurityType
+};

package/dist/esm/utils/environment.js

@@ -0,0 +1,65 @@
+// src/utils/environment.ts
+function getCurrentUrl() {
+  try {
+    if (typeof getCurrentPages !== "function") {
+      return "";
+    }
+    const pages = getCurrentPages();
+    if (pages && pages.length > 0) {
+      const currentPage = pages[pages.length - 1];
+      const route = currentPage.route || "";
+      const options = currentPage.options || {};
+      let query = "";
+      if (options && typeof options === "object") {
+        query = Object.keys(options).map((key) => `${key}=${options[key]}`).join("&");
+      }
+      return query ? `${route}?${query}` : route;
+    }
+  } catch (e) {
+    return "";
+  }
+  return "";
+}
+function getEnvironmentInfo() {
+  const envInfo = {
+    platform: "wechat"
+  };
+  try {
+    const systemInfo = wx.getSystemInfoSync();
+    envInfo.systemInfo = {
+      brand: systemInfo.brand,
+      model: systemInfo.model,
+      system: systemInfo.system,
+      platform: systemInfo.platform,
+      version: systemInfo.version,
+      SDKVersion: systemInfo.SDKVersion
+    };
+    envInfo.screenWidth = systemInfo.screenWidth;
+    envInfo.screenHeight = systemInfo.screenHeight;
+    envInfo.language = systemInfo.language;
+  } catch (e) {
+  }
+  return envInfo;
+}
+function collectEnvironmentTags() {
+  const envInfo = getEnvironmentInfo();
+  const tags = {
+    platform: envInfo.platform
+  };
+  if (envInfo.platform === "wechat" && envInfo.systemInfo) {
+    tags.brand = envInfo.systemInfo.brand;
+    tags.model = envInfo.systemInfo.model;
+    tags.system = envInfo.systemInfo.system;
+    tags.wechatVersion = envInfo.systemInfo.version;
+    tags.SDKVersion = envInfo.systemInfo.SDKVersion;
+    tags.screenWidth = envInfo.screenWidth;
+    tags.screenHeight = envInfo.screenHeight;
+    tags.language = envInfo.language;
+  }
+  return tags;
+}
+export {
+  collectEnvironmentTags,
+  getCurrentUrl,
+  getEnvironmentInfo
+};

package/dist/esm/utils/innerMD5.js

@@ -0,0 +1,123 @@
+// src/utils/innerMD5.ts
+var md5 = (input) => {
+  const k = [
+    3614090360,
+    3905402710,
+    606105819,
+    3250441966,
+    4118548399,
+    1200080426,
+    2821735955,
+    4249261313,
+    1770035416,
+    2336552879,
+    4294925233,
+    2304563134,
+    1804603682,
+    4254626195,
+    2792965006,
+    1236535329,
+    4129170786,
+    3225465664,
+    643717713,
+    3921069994,
+    3593408605,
+    38016083,
+    3634488961,
+    3889429448,
+    568446438,
+    3275163606,
+    4107603335,
+    1163531501,
+    2850285829,
+    4243563512,
+    1735328473,
+    2368359562,
+    4294588738,
+    2272392833,
+    1839030562,
+    4259657740,
+    2763975236,
+    1272893353,
+    4139469664,
+    3200236656,
+    681279174,
+    3936430074,
+    3572445317,
+    76029189,
+    3654602809,
+    3873151461,
+    530742520,
+    3299628645,
+    4096336452,
+    1126891415,
+    2878612391,
+    4237533241,
+    1700485571,
+    2399980690,
+    4293915773,
+    2240044497,
+    1873313359,
+    4264355552,
+    2734768916,
+    1309151649,
+    4149444226,
+    3174756917,
+    718787259,
+    3951481745
+  ];
+  const str = unescape(encodeURIComponent(input));
+  const x = [];
+  for (let i = 0; i < str.length * 8; i += 8) {
+    x[i >> 5] |= (str.charCodeAt(i / 8) & 255) << i % 32;
+  }
+  x[str.length * 8 >> 5 << 5] |= 128 << str.length * 8 % 32;
+  x[(str.length * 8 + 64 >>> 9 << 4) + 14] = str.length * 8;
+  let a = 1732584193;
+  let b = -271733879;
+  let c = -1732584194;
+  let d = 271733878;
+  for (let i = 0; i < x.length; i += 16) {
+    const olda = a;
+    const oldb = b;
+    const oldc = c;
+    const oldd = d;
+    for (let j = 0; j < 64; j += 1) {
+      let f;
+      let g;
+      if (j < 16) {
+        f = b & c | ~b & d;
+        g = j;
+      } else if (j < 32) {
+        f = d & b | ~d & c;
+        g = (5 * j + 1) % 16;
+      } else if (j < 48) {
+        f = b ^ c ^ d;
+        g = (3 * j + 5) % 16;
+      } else {
+        f = c ^ (b | ~d);
+        g = 7 * j % 16;
+      }
+      const temp = d;
+      d = c;
+      c = b;
+      b = b + (a + f + k[j] + (x[i + g] || 0) << 7 + (j < 16 ? [7, 12, 17, 22][j % 4] : j < 32 ? [5, 9, 14, 20][j % 4] : j < 48 ? [4, 11, 16, 23][j % 4] : [6, 10, 15, 21][j % 4])) | 0;
+      a = temp;
+    }
+    a = a + olda | 0;
+    b = b + oldb | 0;
+    c = c + oldc | 0;
+    d = d + oldd | 0;
+  }
+  const hex = (val) => {
+    let output = "";
+    for (let i = 0; i < 4; i += 1) {
+      output += (val >> i * 8 & 255).toString(16).padStart(2, "0");
+    }
+    return output;
+  };
+  return hex(a) + hex(b) + hex(c) + hex(d);
+};
+export {
+  md5
+};

package/dist/esm/utils/session.js

@@ -0,0 +1,7 @@
+// src/utils/session.ts
+function getSessionId() {
+  return `${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+}
+export {
+  getSessionId
+};

package/dist/esm/utils/tools.js

@@ -0,0 +1,53 @@
+// src/utils/tools.ts
+import { parseStack } from "../stack/stacktrace";
+var now = () => Date.now();
+function safeStringify(obj) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(obj, (_k, v) => {
+    if (v && typeof v === "object") {
+      if (seen.has(v))
+        return "[Circular]";
+      seen.add(v);
+    }
+    return v;
+  });
+}
+function normalizeMessage(message) {
+  return message.replace(/\d+/g, "{n}").replace(/https?:\/\/\S+/g, "{url}").replace(/[a-f0-9]{16,}/gi, "{id}").slice(0, 200);
+}
+function logDebug(debug, ...args) {
+  if (debug)
+    console.debug("[LoggerSDK]", ...args);
+}
+function hashToProb(s) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < s.length; i += 1) {
+    h ^= s.charCodeAt(i);
+    h = h + (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24) >>> 0;
+  }
+  return h % 1e4 / 1e4;
+}
+async function flattenStack(error) {
+  if (!error) {
+    return {
+      location: "",
+      throwable: ""
+    };
+  }
+  const stackFrames = await parseStack(error);
+  return stackFrames && stackFrames.length > 0 ? {
+    location: [stackFrames[0]].map((frame) => `${frame.file}:${frame.line}:${frame.column}`).join("\n	"),
+    throwable: stackFrames.map((frame) => `${frame.file}:${frame.line}:${frame.column}`).join("\n	")
+  } : {
+    location: "",
+    throwable: ""
+  };
+}
+export {
+  flattenStack,
+  hashToProb,
+  logDebug,
+  normalizeMessage,
+  now,
+  safeStringify
+};

package/dist/esm/utils/uuid.js

@@ -0,0 +1,11 @@
+// src/utils/uuid.ts
+function uuid() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.floor(Math.random() * 16);
+    const v = c === "x" ? r : Math.floor(r % 4 + 8);
+    return v.toString(16);
+  });
+}
+export {
+  uuid
+};

package/dist/types/capture/jsError.d.ts

@@ -0,0 +1,2 @@
+import { BaseErrorInfo } from '../types/logEvent';
+export declare function registerJsErrorCapture(debug: boolean, callback: (error: BaseErrorInfo) => void): (() => void) | undefined;

package/dist/types/capture/promiseError.d.ts

@@ -0,0 +1,2 @@
+import { BaseErrorInfo } from '../types/logEvent';
+export declare function registerPromiseErrorCapture(debug: boolean, callback: (error: BaseErrorInfo) => void): (() => void) | undefined;

package/dist/types/capture/resourceError.d.ts

@@ -0,0 +1,2 @@
+import { BaseErrorInfo } from '../types/logEvent';
+export declare function registerResourceErrorCapture(debug: boolean, callback: (error: BaseErrorInfo) => void): (() => void) | undefined;

package/dist/types/capture/wechatError.d.ts

@@ -0,0 +1,3 @@
+import { BaseErrorInfo } from '../types/logEvent';
+export declare function registerWechatErrorCapture(debug: boolean, callback: (error: BaseErrorInfo) => void): (() => void) | undefined;
+export declare function registerWechatUnhandledCapture(debug: boolean, callback: (error: BaseErrorInfo) => void): (() => void) | undefined;

package/dist/types/compress/compression.d.ts

@@ -0,0 +1,9 @@
+/**
+ * gzip 压缩字符串
+ * @param data - 需要压缩的字符串
+ * @returns 压缩后的 Base64 字符串
+ */
+export declare function gzipCompress(data: string): Promise<string>;
+export declare function isGzipSupported(): boolean;
+export declare function convert2Base64FromArray(data: Uint8Array): any;
+export declare function convert2Base64(data: string): Promise<string>;

package/dist/types/config/index.d.ts

@@ -0,0 +1,9 @@
+import { Env } from '../types/env';
+/** 获取 SDK 基础 API */
+export declare const getSDKBaseApi: (env: Env) => "https://apm.pharmacyyf.com" | "https://apm-te.pharmacyyf.com" | "https://chief-dev.yifengx.com";
+/** 获取 SDK 注册 API */
+export declare const getRegisterApi: (env: Env) => string;
+/** 获取 SDK 上报 API */
+export declare const getReportApi: (env: Env) => string;
+/** 获取 SDK 像素上报 API */
+export declare const getPixelBatchApi: (env: Env) => string;

package/dist/types/core/fingerprint.d.ts

@@ -0,0 +1,8 @@
+export declare function generateFingerprint(error: {
+    type: string;
+    message: string;
+    stack?: {
+        file: string;
+        line: number;
+    }[];
+}): string;

package/dist/types/core/httpClient.d.ts

@@ -0,0 +1,11 @@
+export type HttpClientResponse = {
+    type: 'xhr' | 'fetch' | 'wechat';
+    response?: any;
+    error?: any;
+};
+export declare class HttpClient {
+    /**
+     * 发送 POST 请求,需要兼容浏览器和微信小程序
+     */
+    static post(url: string, data: any, token: string): Promise<HttpClientResponse>;
+}