@arms/rum-core 0.1.6 → 0.1.8

package/es/index.d.ts

@@ -19,5 +19,7 @@ export * from './utils/trace';
 export * from './utils/verify';
 export * from './utils/url';
 export * from './utils/events';
+export * from './utils/throttle';
+export * from './utils/disposable';
 export * from './monitor';
 export { Client, Context, Reporter, Shell };

package/es/index.js

@@ -19,5 +19,7 @@ export * from './utils/trace';
 export * from './utils/verify';
 export * from './utils/url';
 export * from './utils/events';
+export * from './utils/throttle';
+export * from './utils/disposable';
 export * from './monitor';
 export { Client, Context, Reporter, Shell };

package/es/model/client.d.ts

@@ -1,6 +1,6 @@
 import { IClient, IConfiguration, IContext, IRumSession } from '../types/client';
-import { IConfigManager } from "../types/config";
-import { RumEvent } from '../types/rum-event';
+import { IConfigManager } from '../types/config';
+import { RumEvent, SendEventOptions } from '../types/rum-event';
 import { IProcessor } from '../types/processor';
 import { ICollector } from '../types/collector';
 import { IReporter } from '../types/reporter';
@@ -12,7 +12,7 @@ declare class Client implements IClient {
     private reporter;
     private ctx;
     init(config: IConfiguration, rumSession?: IRumSession, configManager?: IConfigManager, monitorReporter?: IMonitorReporter): void;
-    sendEvent: (payload: RumEvent) => void;
+    sendEvent: (payload: RumEvent, options?: SendEventOptions) => void;
     setContext(ctx: IContext): void;
     getContext(): IContext;
     useCollectors(collectors: ICollector[]): void;

package/es/model/client.js

@@ -5,7 +5,7 @@ import { EventType } from '../types/client';
 import { EventEmitter } from '../utils/events';
 import { Telemetry } from '../monitor/telemetry';
 import Context from './context';
-import { isFunction } from "../utils/is";
+import { isFunction } from '../utils/is';
 var Client = /*#__PURE__*/function () {
   function Client() {
     var _this = this;
@@ -14,8 +14,8 @@ var Client = /*#__PURE__*/function () {
     this.processors = void 0;
     this.reporter = void 0;
     this.ctx = void 0;
-    this.sendEvent = function (payload) {
-      _this.emitter.emit(EventType.collect, payload);
+    this.sendEvent = function (payload, options) {
+      _this.emitter.emit(EventType.collect, payload, options);
     };
   }
   var _proto = Client.prototype;
@@ -56,7 +56,7 @@ var Client = /*#__PURE__*/function () {
     });
 
     // collector 收集数据统一 push 到各匹配 processor
-    this.emitter.on(EventType.collect, function (payload) {
+    this.emitter.on(EventType.collect, function (payload, options) {
       ctx.setRumEvent(payload);
       for (var _iterator = _createForOfIteratorHelperLoose(processors), _step; !(_step = _iterator()).done;) {
         var processor = _step.value;
@@ -68,12 +68,12 @@ var Client = /*#__PURE__*/function () {
         }
         if (processor.match(ctx)) {
           var res = processor.process(ctx);
-          if (res) {
-            ctx.setRumEvent(res);
-          }
+          // 无论返回值是否为 falsy 都写回 context，
+          // 确保 processor 返回 null/undefined（丢弃事件）时能正确生效
+          ctx.setRumEvent(res);
         }
       }
-      reporter.report(ctx);
+      reporter.report(ctx, options);
     });
     collectors.forEach(function (collector) {
       collector.setup(ctx, _this2.sendEvent);

package/es/model/reporter.d.ts

@@ -1,23 +1,46 @@
 import { IContext } from '../types/client';
-import { RumEvent, IViewData, RumEventBundle } from '../types/rum-event';
+import { RumEvent, IViewData, RumEventBundle, SendEventOptions } from '../types/rum-event';
+/**
+ * 抽象上报器，负责事件排队、批量打包与发送。
+ *
+ * 上报模式（通过 SendEventOptions 控制）：
+ * - 默认：事件进入队列，等待定时器或队列满后批量 flush
+ * - immediate：事件进入队列后立即 flush 整个队列
+ * - single：事件不进队列，独立打包立即上报
+ */
 export default abstract class Reporter {
     name: string;
-    /**
-     * 新上报事件优先检测队列是否超过 50 条，如果超过立即 report。
-     * 如果没超过则检测 FlushTime 内有无新上报事件，如果有新事件，重置 timer，无则 report
-     */
     protected eventQueue: RumEvent[];
     protected ctx: IContext;
     private timer;
     private _init;
     getReportCfg(): import("../types/client").IReportConfig;
-    report(ctx: IContext): void;
+    /**
+     * 上报入口，根据 options 决定上报策略：
+     * - single: 当前事件独立打包立即发送，不影响队列
+     * - immediate: 当前事件入队后立即 flush 整个队列
+     * - 默认: 当前事件入队，等待定时器或队列满后批量 flush
+     */
+    report(ctx: IContext, options?: SendEventOptions): void;
+    /**
+     * 当前事件独立打包上报，不进入批量队列，不重置队列定时器
+     */
+    private flushSingleEvent;
     private pushToQueue;
     /**
      * eventQueue 提取最新 View 作为公共 View，event 中不同 View Event 保留 View id
      */
     protected flushEventQueue(): void;
-    mergeEvent(ctx: IContext, events: RumEvent[], view: IViewData): void;
+    /**
+     * 按 session_id 分组事件并分别打包上报：
+     * - 当前 session 的事件统一打包
+     * - 非当前 session 的事件按各自 session_id 单独打包
+     */
+    protected dispatchEvents(ctx: IContext, events: RumEvent[], view: IViewData): void;
+    /**
+     * 构建 bundle 并发送请求
+     */
+    private buildAndSend;
     private tryRequest;
     /**
      * 接口请求由各平台 sdk reporter 实现

package/es/model/reporter.js

@@ -4,19 +4,24 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { logger } from '../monitor/logger';
 import { RumEventType } from '../types/rum-event';
 import { getErrorID } from '../utils/exception';
-import { isNumber, isObject, isString } from "../utils/is";
-import { verifyProperties } from "../utils/verify";
-import { getUrlParams } from "../utils/url";
+import { isNumber, isObject, isString } from '../utils/is';
+import { verifyProperties } from '../utils/verify';
+import { getUrlParams } from '../utils/url';
 var FLUSH_TIME = 3000;
 var MAX_EVENT_COUNT = 20;
 var attrs = ['app', 'user', 'device', 'os', 'geo', 'isp', 'net', 'properties'];
+
+/**
+ * 抽象上报器，负责事件排队、批量打包与发送。
+ *
+ * 上报模式（通过 SendEventOptions 控制）：
+ * - 默认：事件进入队列，等待定时器或队列满后批量 flush
+ * - immediate：事件进入队列后立即 flush 整个队列
+ * - single：事件不进队列，独立打包立即上报
+ */
 var Reporter = /*#__PURE__*/function () {
   function Reporter() {
     this.name = 'reporter';
-    /**
-     * 新上报事件优先检测队列是否超过 50 条，如果超过立即 report。
-     * 如果没超过则检测 FlushTime 内有无新上报事件，如果有新事件，重置 timer，无则 report
-     */
     this.eventQueue = [];
     this.ctx = void 0;
     this.timer = void 0;
@@ -35,30 +40,62 @@ var Reporter = /*#__PURE__*/function () {
       cfg.maxEventCount = MAX_EVENT_COUNT;
     }
     return cfg;
-  };
-  _proto.report = function report(ctx) {
+  }
+
+  /**
+   * 上报入口，根据 options 决定上报策略：
+   * - single: 当前事件独立打包立即发送，不影响队列
+   * - immediate: 当前事件入队后立即 flush 整个队列
+   * - 默认: 当前事件入队，等待定时器或队列满后批量 flush
+   */;
+  _proto.report = function report(ctx, options) {
     var _this = this;
     this.ctx = ctx;
     if (!this._init) {
       this.init(ctx);
       this._init = true;
     }
+
+    // single 优先级最高：当前事件单独上报，不影响队列
+    if (options && options.single) {
+      this.flushSingleEvent(ctx);
+      return;
+    }
     clearTimeout(this.timer);
     this.pushToQueue();
     var reportConfig = this.getReportCfg();
-    // 超过 MaxCount 直接 flush，否则延迟发送
-    if (this.eventQueue.length >= reportConfig.maxEventCount) {
+    if (options && options.immediate || this.eventQueue.length >= reportConfig.maxEventCount) {
       this.flushEventQueue();
     } else {
       this.timer = setTimeout(function () {
         _this.flushEventQueue();
       }, reportConfig.flushTime);
     }
+  }
+
+  /**
+   * 当前事件独立打包上报，不进入批量队列，不重置队列定时器
+   */;
+  _proto.flushSingleEvent = function flushSingleEvent(ctx) {
+    var _event$view;
+    var session = ctx.session;
+    var sampled = session ? session.getSampled() : true;
+    if (!sampled) return;
+    var event = ctx.getRumEvent();
+    if (!event) return;
+    var views = ctx.getViews();
+    var curView = views[views.length - 1];
+    if (((_event$view = event.view) === null || _event$view === void 0 ? void 0 : _event$view.id) === curView.id) {
+      delete event.view;
+    }
+    this.dispatchEvents(ctx, [event], curView);
   };
   _proto.pushToQueue = function pushToQueue() {
     var ctx = this.ctx,
       eventQueue = this.eventQueue;
     var event = ctx.getRumEvent();
+    // processor 返回 null/undefined 表示丢弃事件，直接跳过
+    if (!event) return;
 
     // 针对相同 event，做 times 合并
     // todo，支持其他类型 event 合并
@@ -116,8 +153,8 @@ var Reporter = /*#__PURE__*/function () {
     views.forEach(function (view) {
       if (view.id === curView.id) {
         var events = eventQueue.filter(function (event) {
-          var _event$view;
-          return ((_event$view = event.view) === null || _event$view === void 0 ? void 0 : _event$view.id) === view.id;
+          var _event$view2;
+          return ((_event$view2 = event.view) === null || _event$view2 === void 0 ? void 0 : _event$view2.id) === view.id;
         });
         events.forEach(function (event) {
           delete event.view;
@@ -126,28 +163,49 @@ var Reporter = /*#__PURE__*/function () {
     });
     var session = ctx.session;
     var sampled = session ? session.getSampled() : true;
-    sampled && this.mergeEvent(ctx, eventQueue, curView);
+    sampled && this.dispatchEvents(ctx, eventQueue, curView);
     this.eventQueue = [];
-  };
-  _proto.mergeEvent = function mergeEvent(ctx, events, view) {
+  }
+
+  /**
+   * 按 session_id 分组事件并分别打包上报：
+   * - 当前 session 的事件统一打包
+   * - 非当前 session 的事件按各自 session_id 单独打包
+   */;
+  _proto.dispatchEvents = function dispatchEvents(ctx, events, view) {
     var config = ctx.getConfig();
     var session = ctx.session;
     var sessionId = session.getSessionId();
-    // events.forEach(event => {
-    //   if (event.session_id === sessionId) {
-    //     delete event.session_id;
-    //   }
-    // });
+    var currentSessionEvents = [];
+    var otherSessionEventsMap = {};
     for (var i = 0; i < events.length; i++) {
       var e = events[i];
-      if (e.session_id === sessionId) {
+      if (!e.session_id || e.session_id === sessionId) {
         delete e.session_id;
+        currentSessionEvents.push(e);
       } else {
-        events.splice(i, 1);
-        i--;
+        var sid = e.session_id;
+        if (!otherSessionEventsMap[sid]) {
+          otherSessionEventsMap[sid] = [];
+        }
+        delete e.session_id;
+        otherSessionEventsMap[sid].push(e);
       }
     }
-    if (events.length === 0) return;
+    if (currentSessionEvents.length > 0) {
+      this.buildAndSend(ctx, config, session, sessionId, currentSessionEvents, view);
+    }
+    var otherSessionIds = Object.keys(otherSessionEventsMap);
+    for (var _i = 0; _i < otherSessionIds.length; _i++) {
+      var _sid = otherSessionIds[_i];
+      this.buildAndSend(ctx, config, session, _sid, otherSessionEventsMap[_sid], view);
+    }
+  }
+
+  /**
+   * 构建 bundle 并发送请求
+   */;
+  _proto.buildAndSend = function buildAndSend(ctx, config, session, sessionId, events, view) {
     var extend = getUrlParams(config.endpoint);
     var bundle = _extends({
       app: {

package/es/model/shell.d.ts

@@ -1,6 +1,6 @@
-import { IClient, IConfiguration } from "../types/client";
-import { RumCustomEvent, RumEvent, RumExceptionEvent, RumResourceEvent, RumViewEvent } from "../types/rum-event";
-import { IShell } from "../types/shell";
+import { IClient, IConfiguration } from '../types/client';
+import { RumCustomEvent, RumEvent, RumExceptionEvent, RumResourceEvent, RumViewEvent, SendEventOptions } from '../types/rum-event';
+import { IShell } from '../types/shell';
 export default abstract class Shell implements IShell {
     client: IClient;
     constructor(config?: IConfiguration);
@@ -8,7 +8,7 @@ export default abstract class Shell implements IShell {
      * 初始化
      */
     abstract init(configuration: IConfiguration): Promise<Shell> | Shell;
-    sendEvent(payload: RumEvent): void;
+    sendEvent(payload: RumEvent, options?: SendEventOptions): void;
     /**
      * get config
      */

package/es/model/shell.js

@@ -1,7 +1,7 @@
 import _extends from "@babel/runtime/helpers/extends";
-import { RumEventType } from "../types/rum-event";
+import { RumEventType } from '../types/rum-event';
 import Client from '../model/client';
-import { isNumber, isObject } from "../utils/is";
+import { isNumber, isObject } from '../utils/is';
 var Shell = /*#__PURE__*/function () {
   function Shell(config) {
     // private callbacks: Function[] = [];
@@ -35,9 +35,9 @@ var Shell = /*#__PURE__*/function () {
    * 初始化
    */
   var _proto = Shell.prototype;
-  _proto.sendEvent = function sendEvent(payload) {
+  _proto.sendEvent = function sendEvent(payload, options) {
     if (this.client) {
-      this.client.sendEvent(payload);
+      this.client.sendEvent(payload, options);
     }
   }
 
@@ -64,10 +64,11 @@ var Shell = /*#__PURE__*/function () {
       event_type: RumEventType.CUSTOM
     });
     this.sendEvent(data);
-  };
+  }
+
   /**
    * 自定义视图上报
-   */
+   */;
   _proto.sendView = function sendView(payload) {
     if (!isObject(payload)) {
       return;
@@ -89,10 +90,11 @@ var Shell = /*#__PURE__*/function () {
       event_type: RumEventType.VIEW
     });
     this.sendEvent(data);
-  };
+  }
+
   /**
    * 自定义异常上报
-   */
+   */;
   _proto.sendException = function sendException(payload) {
     if (!payload.name || !payload.message) {
       return;
@@ -111,10 +113,11 @@ var Shell = /*#__PURE__*/function () {
       source: 'custom'
     });
     this.sendEvent(data);
-  };
+  }
+
   /**
    * 自定义资源上报
-   */
+   */;
   _proto.sendResource = function sendResource(payload) {
     if (!payload.name || !payload.type || !isNumber(payload.duration)) {
       return;

package/es/types/client.d.ts

@@ -1,7 +1,7 @@
 import { ICollector } from './collector';
 import { IProcessor } from './processor';
 import { IReporter } from './reporter';
-import { RumEvent, RumEventBundle, IViewData } from './rum-event';
+import { RumEvent, RumEventBundle, IViewData, SendEventOptions } from './rum-event';
 import { MatchOption } from '../utils/match';
 import { IConfigManager } from './config';
 import { EventEmitter } from '../utils/events';
@@ -119,7 +119,7 @@ export interface IClient {
     /**
      * 业务自定义上传数据
      */
-    sendEvent(payload: RumEvent): void;
+    sendEvent(payload: RumEvent, options?: SendEventOptions): void;
     /**
      * 修改运行时上下文
      */

package/es/types/collector.d.ts

@@ -1,7 +1,7 @@
 import { IContext } from './client';
-import { RumEvent } from './rum-event';
+import { SendEventFn } from './rum-event';
 export interface ICollector {
     name: string;
-    setup(ctx: IContext, sendEvent: (payload: RumEvent) => void): void;
+    setup(ctx: IContext, sendEvent: SendEventFn): void;
     destroy?(): void;
 }

package/es/types/reporter.d.ts

@@ -1,8 +1,8 @@
 import { IContext } from './client';
-import { RumEventBundle } from './rum-event';
+import { RumEventBundle, SendEventOptions } from './rum-event';
 export interface IReporter {
     name: string;
     init(ctx: IContext): void;
     request(ctx: IContext, bundle: RumEventBundle): void;
-    report(ctx: IContext): void;
+    report(ctx: IContext, options?: SendEventOptions): void;
 }

package/es/types/rum-event.d.ts

@@ -7,6 +7,15 @@ export declare enum RumEventType {
     CUSTOM = "custom",
     APPLICATION = "application"
 }
+/** sendEvent 方法的可选配置 */
+export interface SendEventOptions {
+    /** 是否立即上报，将当前事件加入队列后立即 flush 整个队列 */
+    immediate?: boolean;
+    /** 是否单独上报，当前事件不入队列，独立打包发送 */
+    single?: boolean;
+}
+/** 采集器向上层发送事件的统一回调签名 */
+export type SendEventFn = (payload: RumEvent, options?: SendEventOptions) => void;
 export interface BaseObject {
     [key: string]: BaseObjectValue;
 }

package/es/types/rum-event.js

@@ -9,6 +9,10 @@ export var RumEventType = /*#__PURE__*/function (RumEventType) {
   return RumEventType;
 }({});
 
+/** sendEvent 方法的可选配置 */
+
+/** 采集器向上层发送事件的统一回调签名 */
+
 /** 电池信息 */
 
 /** 设备信息 */

package/es/types/shell.d.ts

@@ -1,5 +1,5 @@
-import { IConfiguration } from "./client";
-import { RumEvent } from "./rum-event";
+import { IConfiguration } from './client';
+import { RumEvent, SendEventOptions } from './rum-event';
 /**
  * 每个 sdk shell 导出固定需要实现的基础 api
  * 对外导出 shell 层, 所有 shell 层模型的 API 设计约定：
@@ -15,7 +15,7 @@ export interface IShell {
     /**
      * 自定义上传数据
      */
-    sendEvent(payload: RumEvent): void;
+    sendEvent(payload: RumEvent, options?: SendEventOptions): void;
     /**
      * get config
      */

package/es/utils/base.js

@@ -1,4 +1,5 @@
-import { isFunction } from "./is";
+import { isFunction } from './is';
+import { logger } from '../monitor/logger';
 
 /**
  * 劫持函数或原型
@@ -7,19 +8,74 @@ export function interceptFunction(target, name, callback, isPrototype) {
   if (isPrototype === void 0) {
     isPrototype = false;
   }
-  var registeredMethod = target[name];
-  var proxyMethod = function proxyMethod() {
-    var ctx = isPrototype ? this : target;
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
+  try {
+    var registeredMethod = target[name];
+    var proxyMethod = function proxyMethod() {
+      var ctx = isPrototype ? this : target;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      try {
+        // callback 异常隔离：SDK 采集逻辑出错不能中断客户原函数执行
+        callback.apply(ctx, args);
+      } catch (e) {
+        logger.warn('interceptFunction', "callback error in \"" + name + "\"", e);
+      }
+      if (isFunction(registeredMethod)) {
+        return registeredMethod.apply(ctx, args);
+      }
+    };
+    disguiseProxy(proxyMethod, registeredMethod);
+    target[name] = proxyMethod;
+  } catch (e) {
+    // 劫持安装保护：target 属性只读 accessor 或被 freeze 时（strict mode 下抛 TypeError），
+    // 上报后静默返回，不中断 SDK 初始化
+    logger.warn('interceptFunction', "install proxy failed for \"" + name + "\"", e);
+  }
+}
+
+/**
+ * 伪装代理函数，降低劫持对客户代码的感知：
+ * 1. toString 返回原函数源码（String()、模板字符串、console.log、日志序列化等路径可见原函数）
+ * 2. name/length 与原函数对齐
+ * 3. _rum_intercepted 不可枚举，避免污染 Object.keys / for...in
+ * 注意：defineProperty 在部分小程序运行时可能失败，需降级为直接挂载，不能中断劫持主流程
+ *
+ */
+function disguiseProxy(proxyMethod, originalMethod) {
+  try {
+    if (isFunction(originalMethod)) {
+      Object.defineProperty(proxyMethod, 'toString', {
+        value: function value() {
+          return originalMethod.toString();
+        },
+        writable: true,
+        configurable: true
+      });
+      Object.defineProperty(proxyMethod, 'name', {
+        value: originalMethod.name,
+        configurable: true
+      });
+      Object.defineProperty(proxyMethod, 'length', {
+        value: originalMethod.length,
+        configurable: true
+      });
     }
-    callback.apply(ctx, args);
-    if (isFunction(registeredMethod)) {
-      return registeredMethod.apply(ctx, args);
+    Object.defineProperty(proxyMethod, '_rum_intercepted', {
+      value: originalMethod,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  } catch (e) {
+    // 降级：defineProperty 不可用时直接挂载，保证 restoreFunction 仍可用
+    try {
+      proxyMethod._rum_intercepted = originalMethod;
+    } catch (err) {
+      // 二层保护：strict mode 下对不可扩展对象直接赋值也会抛 TypeError，上报后放弃挂载
+      logger.warn('interceptFunction', 'disguiseProxy fallback failed', err);
     }
-  };
-  proxyMethod._rum_intercepted = registeredMethod;
-  target[name] = proxyMethod;
+  }
 }
 
 /**
@@ -147,72 +203,6 @@ export function delay(func, wait) {
   return setTimeout.apply(void 0, [func, +wait || 0].concat(args));
 }
 
-// // 类型匹配正则
-// const TYPE_REG = /^\[object ([a-z]*)\]$/;
-// /**
-//  * @desc 需要严格区分object和array
-//  * @param obj 任意对象
-//  */
-// export function getType(obj: any) {
-//   let type = Object.prototype.toString.call(obj);
-//   type = type.toLowerCase() || '';
-//   const arr = type.match(TYPE_REG);
-//   return arr?.[1];
-// }
-//
-// /**
-//  * @desc 将字符串转换成正则表达式
-//  * @param str 任意字符串
-//  * 注意，这里只支持 /xxx/ 这种格式，不支持修饰符，例如 /xxx/ig
-//  */
-// export function transStrToReg(str: string) {
-//   if (getType(str) !== 'string') return str;
-//   if (str.length > 2 && str[0] === '/' && str[str.length - 1] === '/') {
-//     return new RegExp(str.substr(1, str.length - 2));
-//   }
-//   return str;
-// }
-//
-// /**
-//  *
-//  * @param config 配置
-//  * @param keys 需要转换的字段
-//  */
-// export function toRegFormat(config: any, keys: any[]) {
-//   if (getType(keys) === 'string') {
-//     keys = [keys];
-//   }
-//   for (let i = 0, len = keys.length; i < len; i++) {
-//     const paths = keys[i].split('.');
-//     const lastIndex = paths.length - 1;
-//     if (!config) break;
-//     let tmp = config;
-//     for (let j = 0, jlen = paths.length; j < jlen; j++) {
-//       if (paths[j] === '[]') {
-//         if (getType(tmp) === 'array') {
-//           let lastPath = paths.splice(j + 1);
-//           lastPath = lastPath.join('.');
-//           for (let x = 0, xlen = tmp.length; x < xlen; x++) {
-//             toRegFormat(tmp[x], lastPath);
-//           }
-//         }
-//         break;
-//       }
-//       // 最后一层了，需要往前一层才能修改对象
-//       if (lastIndex === j && getType(tmp[paths[j]]) === 'string') {
-//         tmp[paths[j]] = transStrToReg(tmp[paths[j]]);
-//         break;
-//       }
-//       tmp = tmp[paths[j]];
-//       if (!tmp) break;
-//     }
-//     if (!tmp || getType(tmp) !== 'array') continue;
-//     for (let j = 0, jlen = tmp.length; j < jlen; j++) {
-//       tmp[j] = transStrToReg(tmp[j]);
-//     }
-//   }
-// }
-
 /**
  * 解析正则表达式字符串，支持 /pattern/flags 格式
  * @param str 正则表达式字符串，如 "/a/ig" 或 "a"

package/es/utils/disposable.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 资源清理组：统一管理多个清理函数的生命周期
+ *
+ * 用于收敛采集器中常见的 cleanup 数组模式，
+ * 避免每个采集器重复实现 push + forEach 逻辑
+ */
+export declare function createDisposableGroup(): {
+    /** 注册一个或多个清理函数 */
+    add(...fns: Array<() => void>): void;
+    /** 执行所有清理函数并重置 */
+    dispose(): void;
+};