gio-miniprogram-sdk 4.0.0

package/src/pluginsOut/ordinary/gioABTest.ts

@@ -0,0 +1,254 @@
+/**
+ * 名称：ABTest插件
+ * 用途：用于提供自动获取AB实验数据和上报实验命中的插件。
+ */
+import { GrowingIOType } from '@@/types/growingIO';
+import {
+  isEmpty,
+  isNaN,
+  isNumber,
+  startsWith,
+  toString
+} from '@@/utils/glodash';
+import { consoleText, hashCode, niceCallback } from '@@/utils/tools';
+
+class GioABTest {
+  // 请求间隔时长
+  public requestInterval: number;
+  // 请求超时时长
+  public requestTimeout: number;
+  // 分流服务请求地址
+  public url: string;
+  // 接口重试计数
+  public retryCount: number;
+  constructor(public growingIO: GrowingIOType, options: any) {
+    const { abServerUrl, requestInterval, requestTimeout } = options ?? {};
+    this.timeoutCheck(requestInterval, requestTimeout);
+    const { emitter } = this.growingIO;
+    this.growingIO.getABTest = this.getABTest;
+    emitter.on('OPTION_INITIALIZED', () => {
+      if (abServerUrl) {
+        this.abtStorageCheck();
+        this.generateUrl(abServerUrl);
+      } else {
+        consoleText(
+          '如果您需要使用ABTest功能，请配置服务地址 abServerUrl!',
+          'warn'
+        );
+      }
+    });
+    this.retryCount = 0;
+  }
+
+  // 两个时长的初始化处理
+  timeoutCheck = (
+    requestInterval: number | string,
+    requestTimeout: number | string
+  ) => {
+    this.requestInterval =
+      isNumber(Number(requestInterval)) &&
+      !isNaN(Number.parseInt(requestInterval as string, 10))
+        ? Number.parseInt(requestInterval as string, 10)
+        : 5;
+    if (this.requestInterval > 60 * 24 || this.requestInterval < 0) {
+      this.requestInterval = 5;
+    }
+    this.requestTimeout =
+      isNumber(Number(requestTimeout)) &&
+      !isNaN(Number.parseInt(requestTimeout as string, 10))
+        ? Number.parseInt(requestTimeout as string, 10)
+        : 1000;
+    if (this.requestTimeout > 5000 || this.requestTimeout < 100) {
+      this.requestTimeout = 1000;
+    }
+  };
+
+  // 检查存储中的实验数据是否已过期
+  abtStorageCheck = () => {
+    const { minipInstance }: any = this.growingIO;
+    const storageKeys = minipInstance.minip?.getStorageInfoSync().keys || [];
+    // 请求标记
+    const abtsKeys = storageKeys.filter((k) => /^\d+_gdp_abt_sign$/.test(k));
+    abtsKeys.forEach((k) => {
+      // 移除过期的数据，防止存储超限
+      const sign = minipInstance.getStorageSync(k);
+      if (!sign || sign < Date.now()) {
+        minipInstance.removeStorageSync(k);
+      }
+    });
+    // abtest数据
+    const abtdKeys = storageKeys.filter((k) => /^\d+_gdp_abtd$/.test(k));
+    abtdKeys.forEach((k) => {
+      // 移除过期的数据，防止存储超限
+      if (isEmpty(minipInstance.getStorageSync(k))) {
+        minipInstance.removeStorageSync(k);
+      }
+    });
+  };
+
+  // 生成存储的hash key
+  getHashKey = (layerId: string | number) => {
+    const {
+      userStore: { uid },
+      vdsConfig: { projectId }
+    } = this.growingIO;
+    return Math.abs(hashCode(`${projectId}#${uid}#${layerId}`));
+  };
+
+  // 生成数据接口地址
+  generateUrl = (abServerUrl: string) => {
+    if (!startsWith(abServerUrl, 'http')) {
+      this.url = `https://${abServerUrl}/diversion/specified-layer-variables`;
+    } else {
+      this.url = `${abServerUrl}/diversion/specified-layer-variables`;
+    }
+  };
+
+  // 获取实验调用
+  getABTest = (layerId: string | number, callback: any) => {
+    if (!this.url) {
+      niceCallback(callback, {});
+      return;
+    }
+    if (!layerId) {
+      consoleText('获取ABTest数据失败! 实验层Id不合法!', 'error');
+      niceCallback(callback, {});
+      return;
+    }
+    const { minipInstance } = this.growingIO;
+    // 接口调用的超时时间
+    const abtSign =
+      minipInstance.getStorageSync(
+        `${this.getHashKey(layerId)}_gdp_abt_sign`
+      ) || 0;
+    // 没有超时尝试取数据
+    const abtData =
+      minipInstance.getStorageSync(`${this.getHashKey(layerId)}_gdp_abtd`) ||
+      {};
+    // 没有有效数据或者接口请求标记超时则从调用分流服务获取数据
+    if (!abtSign || abtSign < Date.now()) {
+      this.initiateRequest(layerId, abtData, callback);
+    } else {
+      niceCallback(callback, abtData);
+    }
+  };
+
+  // 发起请求
+  initiateRequest = (
+    layerId: string | number,
+    originData: any,
+    callback: any
+  ) => {
+    const {
+      userStore: { uid },
+      vdsConfig: { projectId, dataSourceId },
+      minipInstance
+    } = this.growingIO;
+
+    minipInstance.request({
+      url: this.url,
+      header: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      method: 'POST',
+      data: {
+        accountId: projectId,
+        datasourceId: dataSourceId,
+        distinctId: uid,
+        layerId
+      },
+      timeout: this.requestTimeout,
+      success: ({ data }: any) => {
+        if (data.code === 0) {
+          this.experimentVerify({ ...data, layerId }, originData, callback);
+        } else {
+          consoleText(`获取ABTest数据失败! ${data.errorMsg}!`, 'error');
+          // 接口业务失败返回false信息
+          niceCallback(callback, {});
+        }
+        // 接口调用返回后刷新接口调用标记
+        minipInstance.setStorageSync(
+          `${this.getHashKey(layerId)}_gdp_abt_sign`,
+          Date.now() + 1000 * 60 * this.requestInterval
+        );
+      },
+      fail: ({ errMsg }: any) => {
+        // 请求超时（这里没用微信提供的errno，因为它没有值，其他小程序也不一定能兼容）
+        if (errMsg.indexOf('timeout') > -1) {
+          consoleText('获取ABTest数据失败! 请求超时!', 'error');
+          // 接口超时返回false信息
+          niceCallback(callback, {});
+        } else {
+          // 其他失败情况重试
+          if (this.retryCount < 2) {
+            this.initiateRequest(layerId, originData, callback);
+            this.retryCount += 1;
+          } else {
+            consoleText(
+              `获取ABTest数据失败! ${JSON.stringify(errMsg).slice(0, 30)}!`,
+              'error'
+            );
+            // 重试结束后返回false信息
+            niceCallback(callback, {});
+          }
+        }
+      }
+    });
+  };
+
+  // 实验校验（决定是否上报命中事件）
+  experimentVerify = (responseData: any, originData: any, callback: any) => {
+    const { layerId, strategyId, experimentId, variables } = responseData;
+    const abtDataKey = `${this.getHashKey(layerId)}_gdp_abtd`;
+    const abtData = {
+      layerId: toString(layerId),
+      strategyId: toString(strategyId),
+      experimentId: toString(experimentId),
+      variables
+    };
+    const comparisonValue = hashCode(JSON.stringify(abtData));
+    const controlValue = hashCode(JSON.stringify(originData));
+    // 本地实验和请求回来的实验直接做整体hash数据对比
+    if (comparisonValue !== controlValue) {
+      // 存储实验数据
+      this.growingIO.minipInstance.setStorageSync(
+        abtDataKey,
+        abtData,
+        new Date(
+          new Date().getFullYear(),
+          new Date().getMonth(),
+          new Date().getDate() + 1
+        ).getTime()
+      );
+      // 数据不一致重新发命中埋点
+      if (strategyId && experimentId) {
+        this.buildExperimentHitEvent(
+          toString(layerId),
+          toString(experimentId),
+          toString(strategyId)
+        );
+      }
+    }
+    // 回调调用
+    niceCallback(callback, abtData);
+  };
+
+  // 构建实验命中事件
+  buildExperimentHitEvent = (layerId, experimentId, strategyId) => {
+    const {
+      dataStore: { eventContextBuilder, eventConverter }
+    } = this.growingIO;
+    let event = {
+      eventType: 'CUSTOM',
+      eventName: '$exp_hit',
+      attributes: {
+        $exp_layer_id: layerId,
+        $exp_id: experimentId,
+        $exp_strategy_id: strategyId
+      },
+      ...eventContextBuilder(),
+      customEventType: 0
+    };
+    eventConverter(event);
+  };
+}
+
+export default { name: 'gioABTest', method: GioABTest };

package/src/pluginsOut/ordinary/gioCompress.ts

@@ -0,0 +1,251 @@
+/**
+ * 名称：数据加密插件
+ * 用途：用于提供上报数据加密。
+ */
+import { GrowingIOType } from '@@/types/growingIO';
+
+class GioCompress {
+  private f;
+  private _compress;
+  constructor(public growingIO: GrowingIOType) {
+    this.f = String.fromCharCode;
+    this._compress = function (uncompressed, bitsPerChar, getCharFromInt) {
+      if (uncompressed === null) return '';
+      let i,
+        value,
+        context_dictionary = {},
+        context_dictionaryToCreate = {},
+        context_c = '',
+        context_wc = '',
+        context_w = '',
+        context_enlargeIn = 2, // Compensate for the first entry which should not count
+        context_dictSize = 3,
+        context_numBits = 2,
+        context_data = [],
+        context_data_val = 0,
+        context_data_position = 0,
+        ii;
+
+      for (ii = 0; ii < uncompressed.length; ii += 1) {
+        context_c = uncompressed.charAt(ii);
+        if (
+          !Object.prototype.hasOwnProperty.call(context_dictionary, context_c)
+        ) {
+          context_dictionary[context_c] = context_dictSize++;
+          context_dictionaryToCreate[context_c] = true;
+        }
+
+        context_wc = context_w + context_c;
+        if (
+          Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)
+        ) {
+          context_w = context_wc;
+        } else {
+          if (
+            Object.prototype.hasOwnProperty.call(
+              context_dictionaryToCreate,
+              context_w
+            )
+          ) {
+            if (context_w.charCodeAt(0) < 256) {
+              for (i = 0; i < context_numBits; i++) {
+                context_data_val = context_data_val << 1;
+                if (context_data_position === bitsPerChar - 1) {
+                  context_data_position = 0;
+                  context_data.push(getCharFromInt(context_data_val));
+                  context_data_val = 0;
+                } else {
+                  context_data_position++;
+                }
+              }
+              value = context_w.charCodeAt(0);
+              for (i = 0; i < 8; i++) {
+                context_data_val = (context_data_val << 1) | (value & 1);
+                if (context_data_position === bitsPerChar - 1) {
+                  context_data_position = 0;
+                  context_data.push(getCharFromInt(context_data_val));
+                  context_data_val = 0;
+                } else {
+                  context_data_position++;
+                }
+                value = value >> 1;
+              }
+            } else {
+              value = 1;
+              for (i = 0; i < context_numBits; i++) {
+                context_data_val = (context_data_val << 1) | value;
+                if (context_data_position === bitsPerChar - 1) {
+                  context_data_position = 0;
+                  context_data.push(getCharFromInt(context_data_val));
+                  context_data_val = 0;
+                } else {
+                  context_data_position++;
+                }
+                value = 0;
+              }
+              value = context_w.charCodeAt(0);
+              for (i = 0; i < 16; i++) {
+                context_data_val = (context_data_val << 1) | (value & 1);
+                if (context_data_position === bitsPerChar - 1) {
+                  context_data_position = 0;
+                  context_data.push(getCharFromInt(context_data_val));
+                  context_data_val = 0;
+                } else {
+                  context_data_position++;
+                }
+                value = value >> 1;
+              }
+            }
+            context_enlargeIn--;
+            if (context_enlargeIn === 0) {
+              context_enlargeIn = Math.pow(2, context_numBits);
+              context_numBits++;
+            }
+            delete context_dictionaryToCreate[context_w];
+          } else {
+            value = context_dictionary[context_w];
+            for (i = 0; i < context_numBits; i++) {
+              context_data_val = (context_data_val << 1) | (value & 1);
+              if (context_data_position === bitsPerChar - 1) {
+                context_data_position = 0;
+                context_data.push(getCharFromInt(context_data_val));
+                context_data_val = 0;
+              } else {
+                context_data_position++;
+              }
+              value = value >> 1;
+            }
+          }
+          context_enlargeIn--;
+          if (context_enlargeIn === 0) {
+            context_enlargeIn = Math.pow(2, context_numBits);
+            context_numBits++;
+          }
+          // Add wc to the dictionary.
+          context_dictionary[context_wc] = context_dictSize++;
+          context_w = String(context_c);
+        }
+      }
+
+      // Output the code for w.
+      if (context_w !== '') {
+        if (
+          Object.prototype.hasOwnProperty.call(
+            context_dictionaryToCreate,
+            context_w
+          )
+        ) {
+          if (context_w.charCodeAt(0) < 256) {
+            for (i = 0; i < context_numBits; i++) {
+              context_data_val = context_data_val << 1;
+              if (context_data_position === bitsPerChar - 1) {
+                context_data_position = 0;
+                context_data.push(getCharFromInt(context_data_val));
+                context_data_val = 0;
+              } else {
+                context_data_position++;
+              }
+            }
+            value = context_w.charCodeAt(0);
+            for (i = 0; i < 8; i++) {
+              context_data_val = (context_data_val << 1) | (value & 1);
+              if (context_data_position === bitsPerChar - 1) {
+                context_data_position = 0;
+                context_data.push(getCharFromInt(context_data_val));
+                context_data_val = 0;
+              } else {
+                context_data_position++;
+              }
+              value = value >> 1;
+            }
+          } else {
+            value = 1;
+            for (i = 0; i < context_numBits; i++) {
+              context_data_val = (context_data_val << 1) | value;
+              if (context_data_position === bitsPerChar - 1) {
+                context_data_position = 0;
+                context_data.push(getCharFromInt(context_data_val));
+                context_data_val = 0;
+              } else {
+                context_data_position++;
+              }
+              value = 0;
+            }
+            value = context_w.charCodeAt(0);
+            for (i = 0; i < 16; i++) {
+              context_data_val = (context_data_val << 1) | (value & 1);
+              if (context_data_position === bitsPerChar - 1) {
+                context_data_position = 0;
+                context_data.push(getCharFromInt(context_data_val));
+                context_data_val = 0;
+              } else {
+                context_data_position++;
+              }
+              value = value >> 1;
+            }
+          }
+          context_enlargeIn--;
+          if (context_enlargeIn === 0) {
+            context_enlargeIn = Math.pow(2, context_numBits);
+            context_numBits++;
+          }
+          delete context_dictionaryToCreate[context_w];
+        } else {
+          value = context_dictionary[context_w];
+          for (i = 0; i < context_numBits; i++) {
+            context_data_val = (context_data_val << 1) | (value & 1);
+            if (context_data_position === bitsPerChar - 1) {
+              context_data_position = 0;
+              context_data.push(getCharFromInt(context_data_val));
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+            value = value >> 1;
+          }
+        }
+        context_enlargeIn--;
+        if (context_enlargeIn === 0) {
+          context_enlargeIn = Math.pow(2, context_numBits);
+          context_numBits++;
+        }
+      }
+
+      // Mark the end of the stream
+      value = 2;
+      for (i = 0; i < context_numBits; i++) {
+        context_data_val = (context_data_val << 1) | (value & 1);
+        if (context_data_position === bitsPerChar - 1) {
+          context_data_position = 0;
+          context_data.push(getCharFromInt(context_data_val));
+          context_data_val = 0;
+        } else {
+          context_data_position++;
+        }
+        value = value >> 1;
+      }
+
+      // Flush the last char
+      while (true) {
+        context_data_val = context_data_val << 1;
+        if (context_data_position === bitsPerChar - 1) {
+          context_data.push(getCharFromInt(context_data_val));
+          break;
+        } else context_data_position++;
+      }
+      return context_data.join('');
+    };
+  }
+
+  compressToUTF16 = (input) => {
+    const self = this;
+    if (input === null) return '';
+    return (
+      this._compress(input, 15, function (a) {
+        return self.f(a + 32);
+      }) + ' '
+    );
+  };
+}
+
+export default { name: 'gioCompress', method: GioCompress };

package/src/pluginsOut/ordinary/gioCustomTracking.ts

@@ -0,0 +1,71 @@
+/**
+ * 名称：自定义埋点插件
+ * 用途：用于提供自定义埋点的事件构建方法。
+ */
+import { GioCustomTrackingType } from '@@/types/gioCustomTracking';
+import { GrowingIOType } from '@@/types/growingIO';
+
+let ut;
+class GioCustomTracking implements GioCustomTrackingType {
+  constructor(public growingIO: GrowingIOType) {
+    ut = this.growingIO.utils;
+  }
+
+  // 获取动态属性的值
+  getDynamicAttributes = (properties: any) => {
+    if (!ut.isNil(properties)) {
+      ut.keys(properties).forEach((k: string) => {
+        if (ut.isFunction(properties[k])) {
+          properties[k] = properties[k]();
+        } else if (!ut.isArray(properties[k])) {
+          properties[k] = ut.toString(properties[k]);
+        }
+      });
+    }
+    return properties;
+  };
+
+  // 构建自定义埋点事件
+  buildCustomEvent = (name: string, properties: { [key: string]: string }) => {
+    ut.eventNameValidate(name, () => {
+      const {
+        dataStore: { eventContextBuilder, eventInterceptor }
+      } = this.growingIO;
+      const event = {
+        eventType: 'CUSTOM',
+        eventName: name,
+        attributes: ut.limitObject(
+          this.getDynamicAttributes(
+            ut.isObject(properties) && !ut.isEmpty(properties)
+              ? properties
+              : undefined
+          )
+        ),
+        ...eventContextBuilder()
+      };
+      eventInterceptor(event);
+    });
+  };
+
+  // 构建用户变量事件
+  buildUserAttributesEvent = (attributes: { [key: string]: string }) => {
+    const {
+      dataStore: { eventContextBuilder, eventInterceptor, lastVisitEvent }
+    } = this.growingIO;
+    const event = {
+      eventType: 'LOGIN_USER_ATTRIBUTES',
+      attributes: ut.limitObject(attributes),
+      ...eventContextBuilder()
+    };
+    // 该方法很可能被放在在app的onShow中的wx.login异步回调中，
+    // 此时页面的path和query可能还没取到，就拿visit事件的path和query补上
+    if (!event.path) {
+      event.path = lastVisitEvent.path;
+      event.query = lastVisitEvent.query;
+      event.title = lastVisitEvent.title;
+    }
+    eventInterceptor(event);
+  };
+}
+
+export default { name: 'gioCustomTracking', method: GioCustomTracking };