gio-miniprogram-sdk 4.3.2 → 4.4.1

package/src/core/dataStore/eventHooks/index.ts

@@ -1,6 +1,6 @@
 import { EventHooksType, MinipPageType } from '@@/types/eventHooks';
 import { GrowingIOType } from '@@/types/growingIO';
-import { has, isArray, isFunction, typeOf, unset } from '@@/utils/glodash';
+import { has, isArray, isEmpty, isFunction, typeOf } from '@@/utils/glodash';
 import { consoleText, getGlobal, niceTry } from '@@/utils/tools';
 
 import AppEffects from './appEffects';
@@ -17,6 +17,7 @@ class EventHooks implements EventHooksType {
   public defPageCbs: any;
   public appHandlers: string[];
   public pageHandlers: string[];
+  public shareEventTypes: string[];
   public actionEventTypes: string[];
   public originalApp: (any: any) => any;
   public originalPage: (any: any) => any;
@@ -33,6 +34,7 @@ class EventHooks implements EventHooksType {
     this.defPageCbs = {};
     this.appHandlers = config.appHandlers;
     this.pageHandlers = config.pageHandlers;
+    this.shareEventTypes = config.shareEventTypes;
     this.actionEventTypes = config.actionEventTypes;
     this.appEffects = new AppEffects(this.growingIO);
     this.pageEffects = new PageEffects(this.growingIO);
@@ -85,95 +87,135 @@ class EventHooks implements EventHooksType {
     }
   };
 
-  // 生命周期方法effects
+  /**
+   * 执行生命周期回调并广播事件
+   */
+  lifeFcEffectsFn = (instance, args, cType, eventName, result = undefined) => {
+    // 创建参数数组副本
+    const argsArray =
+      typeOf(args) === 'array' ? Array.prototype.slice.call(args) : [];
+    // 如果有结果，添加到参数列表
+    if (!isEmpty(result)) {
+      argsArray.push(result);
+    }
+
+    // 执行effects
+    this[`def${cType}Cbs`][eventName].apply(instance, argsArray);
+
+    // 广播生命周期
+    this.growingIO.emitter.emit(EMIT_MSG.MINIP_LIFECYCLE, {
+      event: `${cType} ${eventName}End`,
+      timestamp: Date.now(),
+      params: { instance, arguments: Array.from(argsArray) }
+    });
+
+    return result;
+  };
+
+  /**
+   * 生命周期方法effects
+   */
   lifeFcEffects = (eventName: string, method: any, cType: 'App' | 'Page') => {
     const self = this;
-    if (['onShareTimeline', 'onAddToFavorites'].includes(eventName)) {
-      // onShareTimeline和onAddToFavorites不能异步执行，单独处理
-      return function (...args) {
-        let result = method.apply(this, args);
-        if (
-          eventName === 'onShareTimeline' &&
-          self.growingIO.vdsConfig.followShare
-        ) {
-          result = self.currentPage.updateTimelineResult(result ?? {});
-        }
-        if (eventName === 'onAddToFavorites') {
-          result = self.currentPage.updateAddFavoritesResult(result ?? {});
-        }
-        const argsArray = Array.prototype.slice.call(args);
-        if (result) {
-          argsArray.push(result);
+
+    return function (...args) {
+      let result;
+
+      // 分享事件单独处理
+      if (self.shareEventTypes.includes(eventName)) {
+        // 先执行分享的生命周期拿到分享数据
+        const originResult = method.apply(this, args) ?? {};
+
+        // sdk跟踪分享事件时才处理，否则直接返回原结果
+        if (!self.growingIO.vdsConfig.followShare) {
+          return originResult;
         }
-        // 执行effects
-        self[`def${cType}Cbs`][eventName].apply(this, argsArray);
-        return result;
-      };
-    } else {
-      // 其他生命周期可以异步执行
-      return async function (...args) {
-        let result;
-        try {
-          // 分享处理
-          if (eventName === 'onShareAppMessage') {
-            // 先执行分享的生命周期拿到分享数据
-            // 与基础库保持一致，没有返回值时默认使用{}
-            result = method.apply(this, args) ?? {};
-            // 如果分享事件是个promise函数，需要等待异步结果
-            if (typeOf(result) === 'promise') {
-              result = await result.then((r) => r);
-            }
-            // 如果返回的对象中包含promise，要等待异步结果
-            if (typeOf(result.promise) === 'promise') {
-              const f = async function () {
-                let sRes = result;
-                return new Promise((resolve) => {
-                  // 如果3秒后result.promise没有返回结果，则返回的是默认的result值
-                  // https://developers.weixin.qq.com/miniprogram/dev/reference/api/Page.html#onShareAppMessage-Object-object
-                  let t = setTimeout(() => {
-                    resolve({ ...sRes });
-                    clearTimeout(t);
-                    t = undefined;
-                  }, 3000);
-                  result.promise.then((res) => {
-                    sRes = res;
-                    resolve({ ...sRes });
-                    clearTimeout(t);
-                    t = undefined;
-                  });
-                });
+        const isPromiseResult = typeOf(originResult) === 'promise';
+        const hasPromiseProperty = typeOf(originResult.promise) === 'promise';
+        // 支付宝的promise会被提前处理过，通过以下两个字段判断是否需要自定义promise
+        const isSpecialPromise =
+          has(originResult, '_result') && has(originResult, '_state');
+
+        // 处理异步分享结果
+        if (isPromiseResult || hasPromiseProperty || isSpecialPromise) {
+          // 创建处理Promise结果的通用函数
+          const handlePromiseResult = (promiseResult = {}) => {
+            try {
+              // 合并原始结果和Promise结果
+              const mergedResult = {
+                ...originResult,
+                ...promiseResult
               };
-              result = { ...result, ...((await f()) as any) };
-              unset(result, 'promise');
-            }
-            if (self.growingIO.vdsConfig.followShare) {
-              result = self.currentPage.updateAppMessageResult(result ?? {});
+
+              // 更新分享内容
+              const updatedResult =
+                self.currentPage.updateShareResult(mergedResult);
+
+              // 执行回调
+              self.lifeFcEffectsFn(this, args, cType, eventName, updatedResult);
+            } catch (error) {
+              consoleText(error, 'error');
             }
+          };
+
+          // 处理整个返回值是Promise的情况
+          if (isPromiseResult) {
+            // 如果三秒内不resolve结果，分享会使用原默认参数
+            Promise.race([
+              originResult,
+              new Promise((resolve) => {
+                setTimeout(() => {
+                  resolve({});
+                }, 3000);
+              })
+            ])
+              .then(handlePromiseResult)
+              .catch((error) => consoleText(error, 'error'));
           }
-          const argsArray = Array.prototype.slice.call(args);
-          if (result) {
-            argsArray.push(result);
+
+          // 处理返回值中包含promise属性的情况
+          if (hasPromiseProperty) {
+            // 如果三秒内不resolve结果，分享会使用原默认参数
+            Promise.race([
+              originResult.promise,
+              new Promise((resolve) => {
+                setTimeout(() => {
+                  resolve({});
+                }, 3000);
+              })
+            ])
+              .then(handlePromiseResult)
+              .catch((error) => consoleText(error, 'error'));
           }
-          // 执行effects
-          self[`def${cType}Cbs`][eventName].apply(this, argsArray);
-        } catch (error) {
-          consoleText(error, 'error');
-        }
-        // 执行分享之外的生命周期函数
-        if (eventName !== 'onShareAppMessage') {
-          result = method.apply(this, args);
+
+          // 处理支付宝特有的promise
+          if (isSpecialPromise) {
+            self.growingIO.minipInstance?.handleSharePromise(
+              originResult,
+              handlePromiseResult
+            );
+          }
+
+          // 直接返回原分享结果继续执行原逻辑
+          result = self.currentPage.updateShareResult(originResult, false);
+        } else {
+          // 没有异步逻辑，直接更新分享内容执行回调
+          result = self.currentPage.updateShareResult(originResult);
+          self.lifeFcEffectsFn(this, args, cType, eventName, result);
         }
-        self.growingIO.emitter.emit(EMIT_MSG.MINIP_LIFECYCLE, {
-          event: `${cType} ${eventName}End`,
-          timestamp: Date.now(),
-          params: { instance: this, arguments: Array.from(args) }
-        });
-        return result;
-      };
-    }
+      } else {
+        // 其他生命周期事件：先执行回调，再执行原方法
+        self.lifeFcEffectsFn(this, args, cType, eventName);
+        result = method.apply(this, args);
+      }
+
+      return result;
+    };
   };
 
-  // 自定义方法effects
+  /*
+   * 自定义方法effects
+   */
   customFcEffects = (eventName: string, method: any) => {
     const self = this;
     return function (...args) {

package/src/core/dataStore/eventHooks/minipPage.ts

@@ -1,12 +1,4 @@
-import {
-  compact,
-  has,
-  head,
-  isEmpty,
-  keys,
-  last,
-  unset
-} from '@@/utils/glodash';
+import { compact, has, isEmpty, keys, last, unset } from '@@/utils/glodash';
 import { GrowingIOType } from '@@/types/growingIO';
 import { MinipPageType, PageShareResult } from '@@/types/eventHooks';
 import {
@@ -23,7 +15,7 @@ import { EVENT } from '@@/types/base';
 
 class MinipPage implements MinipPageType {
   // 根据页面存储的页面参数
-  public queryOption: any;
+  public queryOptions: any;
   // 通过调用wx.setNavigationBarTitle设置的title
   public configuredTitle: any;
   // 页面级属性
@@ -36,12 +28,16 @@ class MinipPage implements MinipPageType {
   public lifeBeforeShow = true;
 
   constructor(public growingIO: GrowingIOType) {
-    this.queryOption = {};
+    this.queryOptions = {};
     this.configuredTitle = {};
     this.pageProps = {};
   }
 
-  // 获取页面地址
+  /**
+   * 获取当前页面路径
+   * 优先级：页面堆栈路径 > 启动参数路径 > 最近 page 事件路径 > 最近 visit 事件路径
+   * 插件环境下无页面时返回插件 appId
+   */
   getPagePath = () => {
     const { minipInstance, inPlugin, dataStore, trackingId } = this.growingIO;
     const path = minipInstance.getCurrentPath();
@@ -61,7 +57,10 @@ class MinipPage implements MinipPageType {
     }
   };
 
-  // 获取页面参数
+  /**
+   * 获取当前页面参数（query）
+   * 优先级：页面堆栈参数 > 生命周期参数 > 启动参数 > 最近 page 事件参数 > 最近 visit 事件参数
+   */
   getPageQuery = () => {
     const { minipInstance, dataStore, trackingId } = this.growingIO;
     const stackPage = minipInstance.getCurrentPage();
@@ -71,13 +70,13 @@ class MinipPage implements MinipPageType {
       const pageParams = stackPage.options ?? stackPage.$taroParams;
       // 堆栈中有页面信息，则使用堆栈中的页面参数
       if (!isEmpty(pageParams)) {
-        // 删掉taro框架中自带的字段
-        unset(pageParams, '$taroTimestamp');
-        // 有页面解析的option直接取
+        // 删掉 taro 框架中自带的字段，删除圈选可能带进来的参数
+        unset(pageParams, ['$taroTimestamp', 'gdpCircleRoomCollectUrl']);
+        // 有页面解析的 option 直接取
         return this.qsQuery(pageParams);
-      } else if (!isEmpty(this.queryOption[stackPath])) {
-        // 没有option从hook获取的生命周期参数中取
-        return this.qsQuery(this.queryOption[stackPath]);
+      } else if (!isEmpty(this.queryOptions[stackPath])) {
+        // 没有 option 从 hook 获取的生命周期参数中取
+        return this.qsQuery(this.queryOptions[stackPath]);
       } else if (stackPath === enterParams.path) {
         // 某些小程序虽然有页面堆栈，但是页面还没加载完，兜底取启动参数
         return this.qsQuery(
@@ -93,16 +92,20 @@ class MinipPage implements MinipPageType {
         getLaunchQuery(enterParams?.query, enterParams?.referrerInfo?.extraData)
       );
     } else {
-      // 作为页面组件时component created生命周期中的埋点会取不到页面堆栈，所以拿最近的一个page事件中的页面信息做兜底
+      // 作为页面组件时 component created 生命周期中的埋点会取不到页面堆栈，所以拿最近的一个 page 事件中的页面信息做兜底
       return dataStore.lastPageEvent[trackingId]?.path
         ? dataStore.lastPageEvent[trackingId]?.query
-        : // 没有最近的一个page事件说明在app初始化的生命周期中，有些框架可能会有异步处理逻辑导致事件触发比visit晚，则使用visit事件中的页面信息兜底
+        : // 没有最近的一个 page 事件说明在 app 初始化的生命周期中，有些框架可能会有异步处理逻辑导致事件触发比 visit 晚，则使用 visit 事件中的页面信息兜底
           dataStore.lastVisitEvent[trackingId]?.query;
     }
   };
 
-  // 获取页面标题
-  // 页面title (优先级：setNavigationBarTitle > data.gioPageTitle[不保证能取到] > config.js中设置的值 > tabBar配置)
+  /**
+   * 获取页面标题
+   * 优先级：setNavigationBarTitle > data.gioPageTitle > config.js 中设置的值 > tabBar 配置
+   * 插件环境下无页面时返回插件 appId
+   * @param trackingId 可选，追踪 id
+   */
   getPageTitle = (trackingId?: string) => {
     const { minipInstance, inPlugin, dataStore } = this.growingIO;
     const path = minipInstance.getCurrentPath();
@@ -122,14 +125,22 @@ class MinipPage implements MinipPageType {
     }
   };
 
-  // 格式化页面参数
+  /**
+   * 格式化页面参数为 query string
+   * 会去除 wxShoppingListScene 字段
+   * @param query 页面参数对象
+   */
   qsQuery = (query = {}) => {
     const slimQuery = { ...query };
     unset(slimQuery, 'wxShoppingListScene');
     return qsStringify(slimQuery);
   };
 
-  // 获取页面来源
+  /**
+   * 获取页面来源（referrer）
+   * 优先级：最近 page 事件路径 > 启动参数 referrerInfo.appId > scene 场景值
+   * @param trackingId 追踪 id
+   */
   getReferralPage = (trackingId: string) => {
     const {
       minipInstance,
@@ -142,69 +153,68 @@ class MinipPage implements MinipPageType {
     );
   };
 
-  // 处理分享参数
-  buildShareQuery(
-    result: PageShareResult // 客户自定义的参数
-  ): [string, string] {
-    // 自定义path的地址参数截取（onShareAppMessage中的页面参数是拼在地址中的）
+  /**
+   * 处理分享参数，生成分享用的 path 和 query
+   * 优先级：result.query > result.path > 当前页面参数（去除 utm_ 开头参数）
+   * @param result PageShareResult 客户自定义的参数
+   * @returns [path, queryString]
+   */
+  buildShareQuery(result: PageShareResult): [string, string] {
+    // 自定义 path 的地址参数截取（onShareAppMessage 中的页面参数是拼在地址中的）
     const customSplit = splitPath(result.path ?? '');
 
-    let path = this.getPagePath();
+    let path = result.path || this.getPagePath();
     let parsedQuery: any = {};
     let resultHasPath = has(result, 'path');
-    // 优先使用自定义的地址
-    if (resultHasPath) {
-      path = head(customSplit);
+    let resultHasQuery = has(result, 'query');
+    // 如果定义了 query 字段则优先取 query 参数
+    if (resultHasQuery) {
+      parsedQuery = qsParse(result.query ?? '') || {};
+    } else if (resultHasPath) {
+      // 没有定义 query 字段则尝试取 path 中的参数
       parsedQuery = qsParse(last(customSplit)) || {};
-    }
+    } else {
+      // 只有在没有自定义 path 和 query 的情况下，才使用页面堆栈中的默认参数并删除 utm 参数
+      const stackPage = this.growingIO.minipInstance.getCurrentPage();
+      // 这里不要直接用对象赋值，下面的 unset 会修改原对象，导致触发一次分享以后当前页面事件中的 utm 参数就会被删除掉
+      parsedQuery = {
+        ...(stackPage.options || this.queryOptions[stackPage.route] || {})
+      };
 
-    // 自定义path中没有截取到query说明是在onShareAppMessage中没有参数，或是在onShareTimeline中需要取自定义query
-    if (isEmpty(parsedQuery)) {
-      parsedQuery = qsParse(result.query ?? '') || {};
+      // 删除 utm_ 参数
       compact(keys(parsedQuery)).forEach((key) => {
-        // 删除从默认页面的query中原有的utm参数，防止带入到下一次分享导致渠道统计错误（如果客户质疑参数被删，让他们自己拼回去或者关followShare）
         if (key.toLowerCase().startsWith('utm_')) {
           unset(parsedQuery, key);
         }
       });
     }
 
-    // 以上两种都是自定义的地址和参数，不做处理直接用，防止出现encode/decode的问题。
-
-    // 自定义query没有值则使用当前页面默认参数
-    // 如果path存在，但是不携带参数，此时不使用当前页面的默认参数
-    if (!resultHasPath && isEmpty(parsedQuery)) {
-      const stackPage = this.growingIO.minipInstance.getCurrentPage();
-      parsedQuery =
-        stackPage.options || this.queryOption[stackPage.route] || {};
-    }
-
     return [path, qsStringify(parsedQuery)];
   }
 
-  // 更新分享结果
-  updateShareResult = (result: PageShareResult) => {
+  /**
+   * 更新分享结果，补全参数
+   * @param result PageShareResult 分享参数对象
+   * @param fillParams 是否补全参数，默认 true
+   * @returns 更新后的 result
+   */
+  updateShareResult = (result: PageShareResult, fillParams = true) => {
     const [path, queryString] = this.buildShareQuery(result);
-    result.path = normalPath(path + (queryString ? `?${queryString}` : ''));
-    result.query = queryString;
-    return result;
-  };
-
-  // 更新分享转发事件的结果
-  updateAppMessageResult = this.updateShareResult;
-
-  // 更新分享朋友圈结果
-  updateTimelineResult = this.updateShareResult;
-
-  // 更新收藏结果
-  updateAddFavoritesResult = (result: PageShareResult) => {
-    const [path, queryString] = this.buildShareQuery(result);
-    result.path = normalPath(path + (queryString ? `?${queryString}` : ''));
-    result.query = queryString;
+    if (fillParams || has(result, 'path')) {
+      result.path = normalPath(path + (queryString ? `?${queryString}` : ''));
+    }
+    if (fillParams || has(result, 'query')) {
+      result.query = queryString;
+    }
     return result;
   };
 
-  // 给事件合并页面属性
+  /**
+   * 给事件合并页面属性
+   * @param trackingId 追踪 id
+   * @param event 事件对象
+   * @returns 合并后的属性对象
+   */
   eventSetPageProps = (trackingId: string, event: EVENT) => {
     const pageProps = niceTry(
       () => this.pageProps[trackingId][this.getPagePath()]

package/src/core/dataStore/eventHooks/pageEffects.ts

@@ -67,7 +67,7 @@ class PageEffects {
     switch (event) {
       case pageListeners.pageLoad: {
         // 获取一次页面参数存起来，防止类似支付宝小程序只能通过生命周期获取页面参数或页面堆栈拿不到页面参数，做兜底
-        currentPage.queryOption[path] =
+        currentPage.queryOptions[path] =
           get(page, 'options') ||
           get(page, '__displayReporter.query') ||
           get(page, '$page.query') ||
@@ -75,7 +75,10 @@ class PageEffects {
           get(page, '$taroParams') ||
           args[0] ||
           {};
-        unset(currentPage.queryOption[path], '$taroTimestamp');
+        unset(currentPage.queryOptions[path], [
+          '$taroTimestamp',
+          'gdpCircleRoomCollectUrl'
+        ]);
         break;
       }
       case pageListeners.pageShow: {
@@ -102,6 +105,7 @@ class PageEffects {
       case pageListeners.pageUnload: {
         break;
       }
+      case pageListeners.shareChat: // 小红书特有事件
       case pageListeners.shareApp: {
         toggleShareOut(true);
         trackersExecute((trackingId: string) => {
@@ -113,6 +117,9 @@ class PageEffects {
         break;
       }
       case pageListeners.shareTime: {
+        if (minipInstance.platform === 'xhsp') {
+          toggleShareOut(true);
+        }
         trackersExecute((trackingId: string) => {
           const { followShare } = getTrackerVds(trackingId);
           if (followShare) {

package/src/core/dataStore/index.ts

@@ -582,7 +582,7 @@ class DataStore implements DataStoreType {
     };
     event.attributes = limitObject({
       ...(event.attributes ?? {}),
-      $from: originResult.from,
+      $from: originResult?.from,
       $target: originResult?.target?.id,
       $share_title: updateResult?.title,
       $share_path: head(uri),

package/src/core/growingIO.ts

@@ -18,7 +18,8 @@ import {
   getPlainPlatform,
   guid,
   limitObject,
-  niceCallback
+  niceCallback,
+  qsParse
 } from '@@/utils/tools';
 import { ALLOW_SET_OPTIONS, DEFAULT_SETTINGS } from '@@/constants/config';
 import { DataStoreType, OriginOptions } from '@@/types/dataStore';
@@ -65,6 +66,7 @@ class GrowingIO implements GrowingIOType {
   // 当前主SDK的trackingId，用于区分事件归属。
   public trackingId: string;
   public subInstance: any;
+  private _identified: boolean;
   constructor() {
     this.utils = { ...glodash, ...tools, qs };
     this.emitter = mitt();
@@ -288,6 +290,8 @@ class GrowingIO implements GrowingIOType {
       this.userStore.setUid(asId);
       // 修改forceLogin配置项
       this.dataStore.setOption(this.trackingId, 'forceLogin', false);
+      // 标记当前已被identify过
+      this._identified = true;
       // 为已积压的请求使用assignmentId全部赋值deviceId
       this.dataStore.trackersExecute((tid: string) => {
         const hq = this.uploader.getHoardingQueue(tid);
@@ -295,6 +299,8 @@ class GrowingIO implements GrowingIOType {
         // 发送积压队列中的请求
         this.uploader.initiateRequest(tid, true);
       });
+    } else if (this._identified) {
+      callError('identify', !1, '请勿重复调用');
     } else {
       callError('identify', !1, 'forceLogin未开启');
     }
@@ -338,9 +344,14 @@ class GrowingIO implements GrowingIOType {
       userId = toString(userId).slice(0, 1000);
       userKey = toString(userKey).slice(0, 1000);
       this.userStore.setUserId(trackingId, userId);
+      const processedUserKey =
+        !isNil(userKey) && toString(userKey).length > 0
+          ? toString(userKey).slice(0, 1000)
+          : '';
+      this.userStore.setUserKey(trackingId, processedUserKey);
       const { idMapping } = this.dataStore.getTrackerVds(trackingId);
-      if (idMapping) {
-        this.userStore.setUserKey(trackingId, isNil(userKey) ? '' : userKey);
+      if (!idMapping && processedUserKey) {
+        consoleText('您设置了 userKey ，请初始化开启 idMapping!', 'warn');
       }
       // 切换userId时重置session
       if (prevId && prevId !== userId) {
@@ -606,6 +617,19 @@ class GrowingIO implements GrowingIOType {
         }
       });
     }
+    // 只有主实例有可能会带圈选的字段
+    if (trackingId === this.trackingId) {
+      // 小程序处于圈选状态时，把圈选上报地址带给web
+      const { circleServerUrl, circleOpen } =
+        this.plugins?.gioEventAutoTracking ?? {};
+      if (circleServerUrl && circleOpen) {
+        // infos.giocircleserverurl = encodeURIComponent(circleServerUrl);
+        const circleParam: any = qsParse(circleServerUrl.split('?')[1]);
+        if (circleParam.roomId) {
+          infos.giocircleroomid = circleParam.roomId;
+        }
+      }
+    }
     return qs.stringify(infos);
   };
 }

package/src/core/uploader.ts

@@ -33,10 +33,10 @@ class Uploader implements UploaderType {
     this.retryLimit = 2;
     this.retryIds = {};
     this.requestingNum = 0;
-    const { emitter, vdsConfig, plugins } = this.growingIO;
-    emitter.on(
+    this.growingIO.emitter.on(
       EMIT_MSG.ON_SEND_BEFORE,
       ({ eventsQueue, requestData, trackingId }) => {
+        const { vdsConfig, plugins } = this.growingIO;
         // 核心逻辑中只发送主实例的事件
         if (trackingId === this.growingIO.trackingId) {
           if (vdsConfig?.tbConfig?.cloudAppId) {
@@ -223,11 +223,20 @@ class Uploader implements UploaderType {
             this.requestFailFn(o);
           });
           consoleText(`请求失败!${JSON.stringify(result)}`, 'error');
+          emitter.emit(EMIT_MSG.ON_SEND_ERROR, {
+            eventsQueue,
+            requestData,
+            trackingId
+          });
         }
       },
       complete: (args: any) => {
         this.requestingNum -= 1;
-        emitter.emit(EMIT_MSG.ON_SEND_AFTER, { result: args, requestData });
+        emitter.emit(EMIT_MSG.ON_SEND_AFTER, {
+          result: args,
+          requestData,
+          trackingId
+        });
         this.initiateRequest(trackingId);
       }
     });

package/src/core/userStore.ts

@@ -50,8 +50,7 @@ class UserStore implements UserStoreType {
     }
     // 存储中拿不到尝试设新值
     if (!this._uid) {
-      this._uid = guid();
-      minipInstance.setStorage(this._getUidKey(), this._uid);
+      this.setUid(guid());
     }
     return this._uid;
   };