@tmsfe/tms-core 0.0.22 → 0.0.26

package/dist/index.js

@@ -1,1764 +0,0 @@
-import { R as Request, g as getLogManager, a as getRealtimeLogManager } from './request-f8a4745b.js';
-import { g as getEnvInfo, a as getAuthInfo, s as setAuthInfo, i as isAppPageExist, b as getHomePage, c as setEnvInfo, d as setAppPagePaths } from './env-c7da70e1.js';
-import { s as syncApi, r as roundStr, f as formatPlate, a as subStr, h as hidePhoneCenter, i as isValidPhone, b as isValidPlate, c as isValidAuthCode, d as formatTime, e as formatTimeStr, g as formatTimeWithDetails, j as dateToString, k as ipxInit, l as isIPX, m as getIpxClass, n as getIpxConfig, o as rpxToPx, p as storage } from './storage-094c6ddb.js';
-import { m as md5, s as serialize } from './objUtils-154b94db.js';
-import { callCloudFunc } from './cloudService.js';
-
-/**
- * @copyright 2020-present, Tencent, Inc. All rights reserved.
- * @author Fenggang.Sun <fenggangsun@tencent.com>
- * @file 快速上报数据，不处理过多逻辑，保证快速上报
- */
-let simulatedUserIdCache; // 模拟用户id在内存里的缓存
-
-const getSystemInfo$1 = () => {
-  const system = syncApi.getSystemInfoSync();
-  const {
-    model = '',
-    version: wxVersion = '',
-    platform = '',
-    SDKVersion = '',
-    host = ''
-  } = system;
-  return {
-    model,
-    wxVersion,
-    platform,
-    SDKVersion,
-    host
-  };
-};
-
-const handleParamOfDifferentType = param => {
-  const data = new Array(41);
-  Object.keys(param).forEach(key => {
-    const valType = typeof param[key];
-    if (valType === 'string') data[key] = param[key];else if (valType === 'object') data[key] = JSON.stringify(param[key]);else data[key] = String(param[key]);
-  });
-  return data;
-};
-
-const defAssign = (value, defaultValue) => value || defaultValue;
-/**
- * @class FastReport
- * @classdesc 快速上报模块，不依赖用户标识和位置
- */
-
-
-class FastReport {
-  /**
-   * @memberof FastReport
-   * @description 快速上报
-   * @param {Object} param 埋点数据
-   * @param {Boolean} simulatedUserId 是否上报模拟用户Id
-   * @param {Number} simulatedUserIdIndex 上报模拟用户ID时放在哪个字段
-   * @param {Boolean} reportShowScene 是否上报小程序onShow场景值
-   * @param {Boolean} appVer 是否上报小程序版本
-   * @returns {Promsie} 返回上报结果
-   */
-  static report(param = {}, simulatedUserId = true, simulatedUserIdIndex = 40, reportShowScene = true, appVer = true) {
-    var _data$;
-
-    if (!param[27]) return Promise.reject('invalid report param');
-    const env = getEnvInfo();
-    const data = handleParamOfDifferentType(param);
-    data[9] = '2';
-    data[33] = encodeURIComponent(JSON.stringify(getSystemInfo$1()));
-
-    if (appVer) {
-      data[10] = defAssign(data[10], env.appVersion);
-    }
-
-    data[26] = defAssign(data[26], (_data$ = data[27]) === null || _data$ === void 0 ? void 0 : _data$[0]);
-    data[28] = env.client;
-
-    if (reportShowScene && !data[29]) {
-      const appShowScene = wx.getStorageSync('appShowScene');
-      if (appShowScene) data[29] = String(appShowScene);
-    }
-
-    if (simulatedUserId && !data[simulatedUserIdIndex]) {
-      data[simulatedUserIdIndex] = FastReport.getSimulatedUserId();
-    }
-
-    return new Request().post('basic/event/upload', {
-      batch: [data]
-    }).catch(() => null);
-  }
-  /**
-   * @memberof FastReport
-   * @description 获取模拟的用户身份标识
-   * @returns {String} 用户的临时标识
-   */
-
-
-  static getSimulatedUserId() {
-    // 优先使用内存级缓存
-    if (simulatedUserIdCache) return simulatedUserIdCache;
-    const key = 'SimulatedUserKey'; // 读取本地缓存记录的值
-
-    simulatedUserIdCache = wx.getStorageSync(key);
-    if (simulatedUserIdCache) return simulatedUserIdCache; // 生成新的值
-
-    const nonce = Math.random().toString(36).substr(2, 10);
-    simulatedUserIdCache = `${Date.now()}_${nonce}`;
-    wx.setStorage({
-      key,
-      data: simulatedUserIdCache
-    });
-    return simulatedUserIdCache;
-  }
-
-}
-
-/**
- * 小程序云控配置实现
- */
-
-const parseAllCfgs = (configPaths, resData, defaultCfgs) => configPaths.map((path, index) => {
-  const found = resData.find(cfg => cfg.configPath === path);
-
-  if (found) {
-    return JSON.parse(found.configValue);
-  }
-
-  if (defaultCfgs && defaultCfgs[index]) {
-    return defaultCfgs[index];
-  }
-
-  return {}; // 没找到配置，返回一个空对象
-});
-
-const formatConfigPaths = configPath => {
-  const configPaths = Array.isArray(configPath) ? configPath : [configPath];
-  const {
-    client
-  } = getEnvInfo();
-  configPaths.forEach((path, index) => {
-    configPaths[index] = path.replace(/\$\{client\}/, client);
-  });
-  return configPaths;
-};
-/**
- * getConfig 批量拉取配置
- * @description 拉取运营平台上的配置内容。关于运营平台的具体用法，参见{@link https://iwiki.woa.com/pages/viewpage.action?pageId=527948584}
- * @category 配置相关
- * @example <caption>拉取单个配置</caption>
- * const cfg = await app.tms.getConfig('/${client}/violation/subscribe', {}, { title: '当前城市不支持订阅'})
- * console.log(cfg); // 成功则返回服务端存储的配置，失败返回默认值
- * @example <caption>批量拉取配置</caption>
-const cfgs = await app.tms.getConfig([
-  '/${client}/home/service',
-  '/${client}/home/navbar',
-], {}, [
-  [
-    { caption: '违章代缴', icon: 'violation.png' }
-  ],
-  { title: '晚上好，欢迎~' }
-]);
-console.log(cfgs); // 成功则返回服务端存储的配置，失败返回默认值
- * @param {String|Array} configPath 配置路径，单个路径或配置路径数组，支持替换${client}为当前小程序。例如在出行小程序，${client}会变替换为sinan
- * @param {Object} extendAttr 扩展属性，传给配置服务用于检索哪个版本的配置适用于当前用户。
- * @param {Object} [defaultCfg] 默认配置，请求失败返回默认值。
- * @returns {Promise<Object|Array<Object>>}
- * 有默认值时，请求失败返回默认值。无默认值时，请求失败返回Promise.reject
- */
-
-
-function getConfig(configPath, extendAttr = {}, defaultCfg) {
-  if (Array.isArray(configPath)) {
-    // 复数形式
-    if (defaultCfg) {
-      // 有默认值
-      if (!Array.isArray(defaultCfg) || configPath.length !== defaultCfg.length) {
-        throw new Error('配置路径和默认值的数组长度不一致');
-      }
-    }
-  }
-
-  const configPaths = formatConfigPaths(configPath);
-  const defaultCfgs = defaultCfg && (Array.isArray(defaultCfg) ? defaultCfg : [defaultCfg]) || null;
-  const extendAttrs = typeof extendAttr === 'string' ? extendAttr : JSON.stringify(extendAttr);
-  const api = new Request();
-  return api.post('marketing/config', {
-    extendAttrs,
-    configPaths
-  }).then((res = {}) => {
-    const {
-      errCode,
-      resData
-    } = res || {};
-
-    if (resData && resData.length > 0) {
-      const parsed = parseAllCfgs(configPaths, resData, defaultCfgs);
-
-      if (Array.isArray(configPath)) {
-        return parsed;
-      }
-
-      return parsed[0];
-    }
-
-    if (defaultCfgs) {
-      return Array.isArray(configPath) ? defaultCfgs : defaultCfgs[0];
-    }
-
-    return Promise.reject({
-      errCode,
-      resData,
-      msg: `获取${configPaths.join(',')}配置失败，接口调用出错`
-    });
-  }).catch(e => {
-    if (defaultCfgs) {
-      return Promise.resolve(Array.isArray(configPath) ? defaultCfgs : defaultCfgs[0]);
-    }
-
-    return Promise.reject({
-      err: e,
-      msg: `获取${configPaths.join(',')}配置失败，接口调用出错`
-    });
-  });
-}
-
-/**
- * @copyright 2021-present, Tencent, Inc. All rights reserved.
- * @author Davislu <davislu@tencent.com>
- * @brief navigator provides some function to navigate pages in miniprogram.
- *
- */
-
-/**
- * DEFN 空方法
- * @private
- * @returns {undefined} 无返回值
- */
-const DEFN = () => {};
-/**
- * navigateToWebview 方法 跳转到小程序的 web-view 容器打开 H5
- * @param {object} setting 配置信息
- * @param {string} setting.url 需要跳转的 H5 连接
- * @param {function} setting.complete 跳转成功后的回调函数
- * @param {function} setting.message 用于获取 H5 中的 postMessage 的数据
- * @param {object} setting.share 页面分享信息
- * @param {string} setting.share.title 页面分享标题
- * @param {string} setting.share.image 页面分享图片
- * @param {string} setting.share.disable 是否禁用页面分享
- * @param {object} setting.navbar 页面导航栏设置
- * @param {string} setting.navbar.frontColor 导航栏字体颜色
- * @param {string} setting.navbar.backgroundColor 导航栏背景颜色
- * @returns {undefined} 无返回值
-*/
-
-
-const navigateToWebview = ({
-  url: webUrl,
-  complete = DEFN,
-  message = DEFN,
-  share = {},
-  navbar = {}
-}) => {
-  const page = '/modules/x/webcontainer/webcontainer';
-  let query = `url=${encodeURIComponent(webUrl)}`;
-
-  if (share.disable) {
-    query += '&disableShare=true';
-  } else if (share.title) {
-    const image = share.image ? `&image=${encodeURIComponent(share.image)}` : '';
-    query += `&title=${encodeURIComponent(share.title)}${image}`;
-  }
-
-  if (navbar.frontColor) query += `&navbarFront=${navbar.frontColor}`;
-  if (navbar.backgroundColor) query += `&navbarBg=${navbar.backgroundColor}`;
-  const url = `${page}${/\?/.test(page) ? '&' : '?'}${query}`;
-  const navSetting = {
-    url,
-    complete
-  };
-  navSetting.events = {
-    onMessage: message
-  };
-  wx.navigateTo(navSetting);
-};
-
-const obj = {
-  navigateToWebview
-};
-var nav = obj;
-
-/* eslint-disable require-jsdoc */
-
-/**
- * Copyright 2017-present, Tencent, Inc.
- * All rights reserved.
- *
- * @desc: 自定义事件机制
- * @author: kexinwu@tencent.com
- *
- */
-
-/**
- * EventDispatcher 类 事件监听器
- * @class EventDispatcher
- * @classdesc 用于统一维护小程序的事件
- */
-class EventDispatcher {
-  constructor() {
-    this.handlers = [];
-  }
-  /**
-   * @memberof EventDispatcher
-   * @param {String} type 事件名
-   * @param {Function} handler 事件处理函数
-   * @returns {Function} handler 事件处理函数
-   */
-
-
-  bind(type, handler) {
-    if (typeof this.handlers[type] === 'undefined') {
-      this.handlers[type] = [];
-    }
-
-    this.handlers[type].push(handler);
-  }
-  /**
-   * @memberof EventDispatcher
-   * @param       {String} type 事件名
-   * @param       {Function} handler 事件处理函数
-   * @returns     {Function} handler 事件处理函数
-   */
-
-
-  bindOnce(type, handler) {
-    if (typeof this.handlers[type] === 'undefined') {
-      this.handlers[type] = [];
-    }
-
-    const isBinded = this.handlers[type].length === 0;
-
-    if (isBinded) {
-      this.handlers[type].push(handler);
-    }
-  }
-  /**
-   * @memberof EventDispatcher
-   * @param {String} type 事件名
-   * @returns {Void} 无返回值
-   */
-
-
-  remove(type) {
-    this.handlers[type] = [];
-  }
-  /**
-   * @memberof EventDispatcher
-   * @param       {String} type 事件名
-   * @param       {Function} handler 事件处理函数
-   * @returns {Void} 无返回值
-   */
-
-
-  unbind(type, handler) {
-    if (this.handlers[type] instanceof Array) {
-      const handlers = this.handlers[type];
-      let i = 0;
-      const l = handlers.length;
-
-      for (; i < l; i += 1) {
-        if (handlers[i] === handler) {
-          break;
-        }
-      }
-
-      handlers.splice(i, 1);
-    }
-  }
-  /**
-   * @memberof EventDispatcher
-   * @param  {Object} evt 事件描述
-   * @param  {String} evt.type 事件类型
-   * @returns     {Function} handler 事件处理函数
-   */
-
-
-  dispatch(evt) {
-    if (this.handlers[evt.type] instanceof Array) {
-      const handlers = this.handlers[evt.type];
-      handlers.forEach(handler => handler(evt));
-    }
-  }
-
-}
-
-const event$2 = new EventDispatcher();
-// 获取位置状态 -- true: 成功 false: 失败
-let getLocationStatus = true; // eslint-disable-line
-const LocationScopeKey = 'scope.userLocation';
-// 获取授权设置promise
-let getSettingPromise;
-const EventName$1 = 'loc_status_changed';
-/**
- * @param {string} scopeKey 授权项
- * @returns {promise} 授权页操作状态
- */
-function openSetting(scopeKey = LocationScopeKey) {
-    return new Promise((resolve, reject) => {
-        // 打开设置页
-        wx.openSetting({
-            success: (res) => {
-                // 从authSetting中获取用户的授权结果
-                const { authSetting } = res;
-                const authResult = authSetting[scopeKey];
-                // 已经打开授权
-                if (authResult) {
-                    resolve(res);
-                    return;
-                }
-                // 未打开授权
-                reject(res);
-            },
-            fail: reject,
-        });
-    });
-}
-/**
- * @description 更新获取位置状态
- * @param {Boolean} status 成功true或失败false
- * @returns {Promise<void>} 用户是否授权
- */
-async function updateLocStatus(status) {
-    if (status && !getLocationStatus) {
-        let isAuthed = false;
-        try {
-            isAuthed = await getSetting();
-            getLocationStatus = true;
-        }
-        catch (e) {
-            if (isAuthed !== false) {
-                event$2.dispatch({ type: EventName$1 });
-            }
-            const timer = setTimeout(() => {
-                updateLocStatus(status);
-                clearTimeout(timer);
-            }, 200);
-        }
-    }
-    else {
-        getLocationStatus = status;
-    }
-}
-/**
- * 获取用户授权信息
- * @param { string } scopeKey 是否授权过位置信息
- * @returns { Promise } 用户授权对象
- */
-function getSetting(scopeKey = LocationScopeKey) {
-    if (getSettingPromise) { // eslint-disable-line
-        return getSettingPromise;
-    }
-    getSettingPromise = new Promise((resolve, reject) => {
-        wx.getSetting({
-            success: ({ authSetting = {} }) => {
-                resolve(authSetting[scopeKey]);
-                getSettingPromise = null;
-            },
-            fail: (err) => {
-                getSettingPromise = null;
-                const { errMsg = '' } = err || {};
-                // wx.getSetting接口没有响应时errMsg
-                const reason = 'getSetting:fail data no response';
-                // 部分机型上，wx.getSetting接口没有响应，此时，当做位置开关是打开的来处理
-                if (errMsg.indexOf(reason) > -1) {
-                    resolve(true);
-                    return;
-                }
-                reject(err);
-            },
-        });
-    });
-    return getSettingPromise;
-}
-/**
- * getTextByReason 获取提示语文案
- * @param {*} locationEnabled 是否开启位置授权
- * @param {*} isSysAndWechatAllowedGetLoc 是否开启微信位置授权
- * @returns {object} 提示语文案
- */
-function getTextByReason(locationEnabled, isSysAndWechatAllowedGetLoc) {
-    const authLevelName = locationEnabled ? '微信' : '系统';
-    const confirmText = isSysAndWechatAllowedGetLoc ? '去开启' : '好的';
-    return { authLevelName, confirmText };
-}
-/**
-* @function
-* @description 获取设备系统信息
-* @returns      {Object} 设备系统信息
-*/
-function getSystemInfo() {
-    try {
-        const sys = wx.getSystemInfoSync();
-        // 方便开发时调试
-        if (sys.platform === 'devtools') {
-            sys.locationEnabled = true;
-            sys.locationAuthorized = true;
-        }
-        return sys;
-    }
-    catch (err) { }
-}
-/**
- * @function
- * @description 格式化城市编码
- * @param       {String} cityCode 城市编码，以国家编码开始
- * @param       {String} nationCode 国家编码
- * @returns      {String} 去掉国家编码后的城市编码
- */
-function formatCityCode(cityCode, nationCode) {
-    let code = cityCode;
-    if (cityCode.startsWith(nationCode)) {
-        code = cityCode.substr(nationCode.length);
-    }
-    return code;
-}
-/**
- * 格式化poi数据
- * @param {Object} geo 逆地址解析接口返回的数据
- * @returns {object} 格式化后的poi结果
- */
-function formatPoi(geo) {
-    const { pois = [], address_reference: addressRefer } = geo;
-    if (pois.length) {
-        return pois[0];
-    }
-    if (addressRefer?.landmark_l2) {
-        return addressRefer.landmark_l2;
-    }
-    return {};
-}
-
-const event$1 = new EventDispatcher();
-let getLocPromise = null;
-// 用户位置信息缓存
-let userLocationCache$1;
-// 默认获取经纬度坐标的名称
-const defaultLocationType = 'gcj02';
-// 派发事件的名称
-const EventName = 'loc_status_changed';
-/**
- * @private 将wx.getLocation获取位置方法用promise封装
- * @param { string } type 获取位置类型
- * @returns { Promise<any> } 用户位置信息
- */
-function getWxLocation(type = defaultLocationType) {
-    return new Promise((resolve, reject) => {
-        wx.getLocation({
-            type,
-            success: (res) => {
-                resolve(res);
-            },
-            fail: reject,
-        });
-    });
-}
-// 是否开启监听位置变更
-let isListenerLocation = false;
-/**
- * @class Location
- * @classdesc 基于微信api，封装location相关的接口。 包括监听位置变化， 获取用户位置信息
- * 获取位置授权等等。业务无关
- */
-class LocationBase {
-    /**
-     * @private 开启监听位置变更，要在授权之后才能开启
-     */
-    listenerLocation() {
-        if (!isListenerLocation) {
-            isListenerLocation = true;
-            wx.onLocationChange(this.subscribeLocationChnage);
-            wx.startLocationUpdate({});
-        }
-    }
-    /**
-     * 获取用户当前位置(经纬度)
-     * @memberof Location
-     * @param {boolean} showModalWhenCloseAuth 获取位置时，如果用户关闭了位置授权，是否弹窗提示用户打开授权
-     * @param {string}  type 坐标类型
-     * @param {string}  content 弹窗内容
-     * @param {boolean} showCancel 是否显示取消按钮
-     * @returns {Promise<LOC|ERR>} 返回对象
-     * @returns {Promise<LOC|ERR>} 返回对象
-     */
-    getLocation(showModalWhenCloseAuth, type, content = '', showCancel = true) {
-        // 如果缓存中没有， 并且getLocPromise有值， 说明正在请求中。 返回请求的promise
-        if (!userLocationCache$1 && getLocPromise) { // eslint-disable-line
-            return getLocPromise;
-        }
-        // 如果缓存中没有， 并且getLocPromise没有值，新建一个请求
-        if (!userLocationCache$1 && !getLocPromise) { // eslint-disable-line
-            getLocPromise = this.getWxLocationPromise(showModalWhenCloseAuth, type, content, showCancel);
-            return getLocPromise;
-        }
-        // 缓存中有数据， 证明用户已经获取过， 那么直接返回缓存中的位置
-        return Promise.resolve(userLocationCache$1);
-    }
-    /**
-     * @description 获取位置(经纬度)底层封装
-     * @memberof Location
-     * @param {boolean} showModalWhenCloseAuth 获取位置时，如果用户关闭了位置授权，是否弹窗提示用户打开授权
-     * @param {string}  type 坐标类型
-     * @param {string}  content 弹窗内容
-     * @param {boolean} showCancel 是否显示取消按钮
-     * @returns {Promise<LOC|ERR>} 返回对象
-     * @example
-     * <caption>LOC类型示例</caption>
-     * {
-     *   cityName: '北京市',
-     *   cityCode: '100100',
-     *   latitude: 325.255333,
-     *   longitude: 116.2545454,
-     *   adCode: 1212144,
-     *   poi: {
-     *     id: '1114545554511',
-     *     title: '腾讯北京总部大厦',
-     *     address : '北京市海淀区东北旺西路',
-     *   }
-     */
-    getWxLocationPromise(showModalWhenCloseAuth, type, content = '', showCancel = true) {
-        return new Promise((resolve, reject) => {
-            getWxLocation(type).then((res) => {
-                this.listenerLocation();
-                userLocationCache$1 = res;
-                // 更新用户状态 -- todo
-                updateLocStatus(true);
-                resolve(res);
-            })
-                .catch((err) => {
-                getLocPromise = null;
-                updateLocStatus(false);
-                this.openLocationAuth(showModalWhenCloseAuth, type, content, showCancel, err).then((res) => {
-                    resolve(res);
-                }, (err) => {
-                    reject(err);
-                });
-            });
-        });
-    }
-    /**
-     * 如果没有权限，自动开启授权弹窗
-     * @memberof Location
-     * @param {boolean} showModalWhenCloseAuth 获取位置时，如果用户关闭了位置授权，是否弹窗提示用户打开授权
-     * @param {string}  type 坐标类型
-     * @param {string}  content 弹窗内容
-     * @param {boolean} showCancel 是否显示取消按钮
-     * @param {object} err 错误信息
-     * @returns {Promise} 返回对象
-     */
-    openLocationAuth(showModalWhenCloseAuth, type, content, showCancel, err) {
-        return new Promise((resolve, reject) => {
-            const { locationEnabled, locationAuthorized } = getSystemInfo();
-            // 系统位置定位开关打开 && 允许微信使用位置定位能力开关打开
-            if (locationEnabled && locationAuthorized) {
-                if (err.errMsg.search(/auth [deny|denied]|authorize/) < 0) {
-                    reject();
-                    return;
-                }
-            }
-            if (!showModalWhenCloseAuth) {
-                const rejectData = { ...err, unAuthed: true };
-                reject(rejectData);
-                return;
-            }
-            // 控制地理位置开关的名称(系统控制的开关，还是微信层面的开关)
-            const isSysAndWechatAllowedGetLoc = (locationEnabled && locationAuthorized);
-            const { authLevelName, confirmText } = getTextByReason(locationEnabled, isSysAndWechatAllowedGetLoc);
-            wx.showModal({
-                confirmText,
-                title: `未开启${authLevelName}位置信息权限`,
-                content: content || `开启${authLevelName}位置信息权限\n体验更顺畅的出行服务`,
-                showCancel: (showCancel && isSysAndWechatAllowedGetLoc),
-                confirmColor: '#4875fd',
-                success: (res) => {
-                    // 用户拒绝去授权
-                    if (!res.confirm || !locationEnabled || !locationAuthorized) {
-                        const rejectData = { ...err, unAuthed: true };
-                        return reject(rejectData);
-                    }
-                    // 用户同意去打开授权(只是打开小程序设置页，用户不一定打开了位置授权，所以需要重新进行获取位置)
-                    openSetting()
-                        .then(() => {
-                        resolve(this.getLocation(showModalWhenCloseAuth, type, content, showCancel));
-                    })
-                        .catch((err) => {
-                        const rejectData = { ...err, unAuthed: true };
-                        reject(rejectData);
-                    });
-                },
-            });
-        });
-    }
-    /**
-     * 订阅用户位置信息变化
-     * @param { object } res 用户位置信息对象
-     * @returns { undefined } no retrurn
-     */
-    subscribeLocationChnage(res) {
-        userLocationCache$1 = res;
-    }
-    /**
-     * @description
-     * 以静默方式获取用户位置(经纬度)，说明如下：<br>
-     * 1、从未授权情况下 | 用户删除小程序之后调用该方法不会弹微信自带的授权弹窗；<br>
-     * 2、拒绝授权后，调用该方法不会弹窗提示用户去授权（wx.showModal）；<br>
-     * @memberof Location
-     * @param {String} type 非必填。坐标类型，默认'gcj02'
-     * @returns {Promise<LOC|ERR>} 返回位置信息
-     * @example
-     * <caption>LOC类型示例</caption>
-     * {
-     *    latitude: 33.253321,
-     *    longitude: 115.2444,
-     * }
-     * @example
-     * <caption>ERR类型示例</caption>
-     * {
-     *   err,
-     *   unAuthed: true,
-     *   locationScopeStatus: false
-     * }
-     */
-    async getLocationSilent(type) {
-        let err = null;
-        let locationScopeStatus;
-        try {
-            locationScopeStatus = await getSetting();
-            // 用户已授权. locationScopeStatus = true
-            if (locationScopeStatus) {
-                return this.getLocation(false, type);
-            }
-        }
-        catch (ex) {
-            err = ex;
-        }
-        updateLocStatus(false);
-        // 用户关闭了授权. locationScopeStatus = false
-        // 用户未授权过(删除小程序之后再次打开小程序). locationScopeStatus = undefined
-        return Promise.reject({ err, unAuthed: true, locationScopeStatus });
-    }
-    /**
-     * @memberof Location
-     * @description 监听获取位置状态变化(目前只有失败->成功时会触发事件)
-     * @param       {Function} cb 监听事件回调函数
-     * @returns {void}
-     */
-    onLocStatusChange(cb) {
-        if (cb && typeof cb === 'function') {
-            event$1.bind(EventName, cb);
-        }
-    }
-}
-var LocationBase$1 = LocationBase;
-
-const request = new Request();
-const event = new EventDispatcher();
-const userLocationCache = {}; // 获取位置缓存
-// 用户手动选择的位置信息（切换城市后的位置信息）
-let userLocation;
-// 用户所在的城市
-let cityTheUserAt = '';
-// 用户城市变化事件名
-const CityChangeEventName = 'loc_city_changed';
-const LocationType = 'gcj02'; // 获取经纬度时的坐标名称
-let ipLocationPromise = null; // ip定位请求的promise
-/**
- * @class Location
- * @classdesc 基于LocationBase，封装业务侧位置的接口。 将用户经纬度转化为城市等展示信息
- */
-class Location extends LocationBase$1 {
-    // 默认位置信息
-    locForNoAuth = {
-        province: '广东省',
-        cityCode: '440300',
-        cityName: '深圳市',
-        latitude: 22.54286,
-        longitude: 114.05956,
-    };
-    /**
-     * 构造函数
-     */
-    constructor() {
-        super();
-    }
-    /**
-     * 获取解析后的用户位置， 比如城市信息
-     * @param { number } lat 用户纬度信息
-     * @param { number } lng 用户经度信息
-     * @param { number } getPoi 位置
-     * @returns { Promise<PostionType | void> } 获取位置信息的promise
-     */
-    getPoiInfo(lat, lng, getPoi) {
-        // 优先查询缓存中是否有位置信息，如果有直接返回
-        const cacheName = `${lat}-${lng}-${getPoi}`;
-        // @ts-ignore
-        if (userLocationCache[cacheName]) { // eslint-disable-line
-            return userLocationCache[cacheName];
-        }
-        userLocationCache[cacheName] = request.post('basic/lbs/decode', { lat, lng, getPoi }).then((res) => {
-            const { errCode, resData = {} } = res;
-            if (errCode === 0) {
-                const { result = {} } = resData;
-                const { ad_info: adInfo = {} } = result;
-                const loc = {
-                    province: adInfo.province,
-                    cityName: adInfo.city,
-                    adCode: adInfo.adcode,
-                    cityCode: formatCityCode(adInfo.city_code, adInfo.nation_code),
-                    latitude: lat,
-                    longitude: lng,
-                };
-                if (getPoi === 0) {
-                    return loc;
-                }
-                loc.adCode = adInfo.adcode;
-                loc.poi = formatPoi(result);
-                return loc;
-            }
-            return Promise.reject(res);
-        })
-            .catch(err => Promise.reject(err));
-        return userLocationCache[cacheName];
-    }
-    /**
-     * @function
-     * @memberof Location
-     * @description 获取位置、城市信息
-     * @param       {Boolean} showModalWhenCloseAuth 获取位置时，如果用户关闭了位置授权，是否弹窗提示用户打开授权
-     * @param       {String}  type 坐标类型
-     * @param       {String}  content 弹窗内容
-     * @param       {Number}  getPoi 是否获取详细poi信息， 0 - 不获取(不返回poi字段)， 1 - 获取(返回poi字段)
-     * @returns {Promise<POI|ERR>} 返回对象
-     * @example
-     * <caption>POI类型示例</caption>
-     * {
-     *   cityName: '北京市',
-     *   cityCode: '100100',
-     *   province: '北京市',
-     *   latitude: 325.255333,
-     *   longitude: 116.2545454,
-     *   adCode: 1212144,
-     *   poi: {
-     *     id: '1114545554511',
-     *     title: '腾讯北京总部大厦',
-     *     address : '北京市海淀区东北旺西路',
-     *   }
-     * }
-     * @example
-     * <caption>ERR类型示例</caption>
-     * {
-     *   err,
-     *   unAuthed: true,
-     *   locationScopeStatus: false
-     * }
-     */
-    getLocationDetail(showModalWhenCloseAuth = false, type = LocationType, content = '', getPoi = 0) {
-        return this.getLocation(showModalWhenCloseAuth, type, content)
-            .then((res) => this.getPoiInfo(res.latitude, res.longitude, getPoi))
-            .catch(err => Promise.reject(err));
-    }
-    /**
-     * @description 以静默方式获取用户详细位置(经纬度，poi信息， 省市信息)，说明如下：<br>
-     * 1、从未授权情况下 | 用户删除小程序之后调用该方法不会弹微信自带的授权弹窗；<br>
-     * 2、拒绝授权后，调用该方法不会弹窗提示用户去授权（wx.showModal）；<br>
-     * @memberof Location
-     * @param {Number} getPoi 是否获取详细poi信息， 0 - 不获取(不返回poi字段)， 1 - 获取(返回poi字段)
-     * @param {String} type 非必填。坐标类型，默认'gcj02'
-     * @returns {Promise<LOC|ERR>} 返回对象
-     * @example
-     * <caption>LOC类型示例</caption>
-     * {
-     *   cityName: '北京市',
-     *   cityCode: '100100',
-     *   latitude: 325.255333,
-     *   longitude: 116.2545454,
-     *   adCode: 1212144,
-     *   poi: {
-     *     id: '1114545554511',
-     *     title: '腾讯北京总部大厦',
-     *     address : '北京市海淀区东北旺西路',
-     *   }
-     * }
-     * @example
-     * <caption>ERR类型示例</caption>
-     * {
-     *   err,
-     *   unAuthed: true,
-     *   locationScopeStatus: false
-     * }
-     */
-    getLocationDetailSilent(getPoi = 0, type = 'gcj02') {
-        return this.getLocationSilent(type)
-            .then((res) => this.getPoiInfo(res.latitude, res.longitude, getPoi))
-            .catch(err => Promise.reject(err));
-    }
-    /**
-     * @description 获取用户手动选择的位置信息
-     * @memberof Location
-     * @returns {Null|LOC} 返回用户位置信息
-     * @example
-     * <caption>LOC类型示例</caption>
-     * {
-     *   province: '北京市',
-     *   cityName: '北京市',
-     *   cityCode: '100100',
-     *   latitude: 325.255333,
-     *   longitude: 116.2545454,
-     *   adCode: 1212144,
-     * }
-    */
-    getUserLocation() {
-        return userLocation;
-    }
-    /**
-     * @description 设置用户位置（小程序生命周期内有效）
-     * @memberof Location
-     * @param {Object} loc 用户手动选择的位置
-     * @params {String} loc.province 省份
-     * @params {String} loc.cityName 城市
-     * @params {String} loc.cityCode citycode
-     * @params {Number} loc.latitude 纬度
-     * @params {Number} loc.longitude 经度
-     * @params {Number} loc.adCode adCode
-     * @returns {Void} 无返回值
-     * @example
-     * <caption>loc类型示例</caption>
-     * {
-     *   province: '北京市',
-     *   cityName: '北京市',
-     *   cityCode: '100100',
-     *   latitude: 325.255333,
-     *   longitude: 116.2545454,
-     *   adCode: 1212144,
-     * }
-     */
-    setUserLocation(loc) {
-        if (!loc || typeof loc !== 'object') {
-            return;
-        }
-        // 如果城市发生变化，派发事件
-        const { cityName: curCityName } = loc;
-        if (curCityName && (cityTheUserAt !== curCityName)) {
-            cityTheUserAt = curCityName;
-            userLocation = loc;
-            event.dispatch({ type: CityChangeEventName });
-        }
-    }
-    /**
-     * @description 获取用户选择的城市位置信息 或者 用户真实的位置信息（这个方法说明有问题）
-     * @memberof Location
-     * @param {Boolean} showModalWhenCloseAuth 没有授权时是否展示授权弹窗
-     * @returns {Promise} 用户位置信息
-     */
-    async getMergedLocation(showModalWhenCloseAuth = true) {
-        const userLocatioin = this.getUserLocation();
-        // 优先用户选择的城市
-        if (userLocatioin) {
-            return userLocatioin;
-        }
-        return await this.getLocationDetail(showModalWhenCloseAuth, LocationType);
-    }
-    /**
-     * @memberof Location
-     * @description 监听用户城市变化(如: 北京市->深圳市)
-     * @param       {Function} cb 监听事件回调函数
-     * @returns {void}
-     */
-    onCityChange(cb) {
-        if (cb && typeof cb === 'function') {
-            event.bind(CityChangeEventName, cb);
-        }
-    }
-    /**
-     * @memberof Location
-     * @description 获取路线规划
-     * @param       {String} to 目的地坐标，格式：lat,lng
-     * @param       {String} depart 出发地坐标，格式：lat,lng
-     * @param       {String} mode 出行方式， driving 驾车[默认]
-     * @returns     {Object} result.routes 返回数据 [{}, ...]
-     */
-    async getRoute(to, depart, mode = 'driving') {
-        let from = depart;
-        const coorReg = new RegExp(/(\d+\.\d{6,}),(\d+\.\d{6,})/);
-        if (!coorReg.test(to))
-            throw Error('目的地参数格式错误');
-        if (!coorReg.test(from)) { // 出发地缺省使用当前位置
-            const { latitude, longitude } = await this.getMergedLocation();
-            from = `${latitude},${longitude}`;
-        }
-        return request.post('basic/lbs/direction', { from, to, mode });
-    }
-    /**
-     * ip定位
-     * 原理：通过调手图接口查询当前IP所在位置，市级的准确率是91%
-     * 注意：由于服务端对该查询服务有次数限制，所以本函数会缓存成功的promise
-     * @param force 是否清除上次的缓存重新请求
-     */
-    getIpLocation(force = false) {
-        if (ipLocationPromise === null || force) {
-            ipLocationPromise = new Promise((resolve, reject) => {
-                request.post('basic/lbs/decodeip')
-                    .then((res) => {
-                    if (res.errCode === 0) {
-                        resolve(res.resData);
-                        return;
-                    }
-                    reject({ erMsg: res.errMsg });
-                    ipLocationPromise = null;
-                })
-                    .catch((e) => {
-                    reject(e);
-                    ipLocationPromise = null;
-                });
-            });
-        }
-        return ipLocationPromise;
-    }
-}
-// 因为在构造函数中会用到wx的api，所以使用到时才实例化
-let instance;
-function getLocInstance() {
-    if (!instance) {
-        instance = new Location();
-    }
-    return instance;
-}
-
-const R = new Request();
-const ReportInterval = 3000; // 轮训上报间隔
-
-const ReportDataQueue = []; // 上报数据队列
-
-let ReportTaskId = -1; // 轮训上报id
-
-let appShowOptions = null; // 设置小程序onShow参数
-
-function getAppShowOptions() {
-  if (appShowOptions === null) {
-    try {
-      appShowOptions = wx.getLaunchOptionsSync();
-    } catch (_) {
-      appShowOptions = {};
-    }
-  }
-
-  return appShowOptions;
-}
-
-function getTMS() {
-  return getApp({
-    allowDefault: true
-  }).tms;
-} // 缓存系统信息，避免每次都重新获取系统信息
-
-
-let systemPromise = null;
-/**
- * 获取系统信息
- * @private
- * @returns {object} 系统信息
- */
-
-const getSystemPromise = () => {
-  if (systemPromise === null) {
-    systemPromise = new Promise(resolve => {
-      wx.getSystemInfo({
-        success: systemInfo => {
-          const {
-            model,
-            version: wxVersion,
-            platform,
-            SDKVersion,
-            host
-          } = systemInfo;
-          resolve({
-            model,
-            wxVersion,
-            platform,
-            SDKVersion,
-            host
-          });
-        },
-        fail: () => {
-          resolve({});
-        }
-      });
-    });
-  }
-
-  return systemPromise;
-};
-
-let networkPromise = null;
-/**
- * 获取网络信息
- * @private
- * @returns {string} 网络信息
- */
-
-const getNetworkType = () => {
-  if (networkPromise === null) {
-    networkPromise = new Promise(resolve => {
-      wx.getNetworkType({
-        success: netInfo => {
-          resolve(netInfo.networkType);
-        },
-        fail: () => {
-          resolve('unknown');
-        }
-      });
-    });
-  }
-
-  return networkPromise;
-};
-
-let ProvinceInfoCache = null;
-/**
- * 获取省市信息
- * @private
- */
-
-const getProvinceInfo = () => {
-  if (!ProvinceInfoCache) {
-    ProvinceInfoCache = new Promise(async resolve => {
-      try {
-        const loc = await getLocInstance().getLocationDetailSilent();
-        resolve({
-          cityName: loc.cityName,
-          province: loc.province
-        });
-      } catch (_) {
-        // 获取位置失败时，尝试获取本地存储的位置信息
-        const loc = getLocInstance().getUserLocation();
-
-        if (loc !== null && loc !== void 0 && loc.cityName) {
-          resolve(loc);
-        } else {
-          resolve({
-            cityName: '',
-            province: ''
-          });
-        }
-      }
-    });
-  }
-
-  return ProvinceInfoCache;
-};
-
-let ProvinceInfoCacheByIp = null;
-/**
- * 调接口获取省市信息
- * @private
- */
-
-const getProvinceInfoByIp = () => {
-  if (!ProvinceInfoCacheByIp) {
-    ProvinceInfoCacheByIp = new Promise(async resolve => {
-      try {
-        const loc = await getLocInstance().getIpLocation();
-        const {
-          city,
-          province
-        } = loc.ad_info;
-        resolve({
-          cityName: city,
-          province
-        });
-      } catch (_) {
-        resolve({
-          cityName: '',
-          province: ''
-        });
-      }
-    });
-  }
-
-  return ProvinceInfoCacheByIp;
-}; // 用于缓存用户唯一标识userId
-
-
-let userId = '';
-/**
- * 获取用户唯一标识userId
- * @private
- * @returns {string} userId
- */
-
-const getUserId = async () => {
-  if (userId) {
-    return userId;
-  }
-
-  ({
-    userId
-  } = await getAuthInfo());
-  return userId;
-};
-
-let launchFrom = '';
-/**
- * 获取用户启动小程序时的渠道来源值
- * @private
- * @returns {string} 用户启动小程序时的渠道来源值
- */
-
-const getLaunchFrom = () => {
-  if (launchFrom) {
-    return launchFrom;
-  }
-
-  try {
-    const LaunchOptions = wx.getLaunchOptionsSync() || {};
-    const {
-      query = {}
-    } = LaunchOptions;
-    launchFrom = query.from || '';
-    return launchFrom;
-  } catch (_) {
-    return '';
-  }
-};
-/**
- * 将上报的对象类型的数据转换成数组类型
- * @private
- * @param {object} reportData 需要上报的数据
- * @returns {array} 数组格式的上报数据
- */
-
-
-const getReportDataList = (reportData = {}) => {
-  const reportList = [];
-  reportList.length = 40;
-  Object.keys(reportData).forEach(key => {
-    const reportIndex = Number(key);
-    reportList[reportIndex] = reportData[key];
-  });
-  return reportList;
-}; // 小程序版本号
-
-
-let verNum = null;
-
-function getMiniProgramVersion() {
-  if (verNum === null) {
-    const {
-      miniProgram: {
-        version
-      } = {}
-    } = wx.getAccountInfoSync() || {};
-    verNum = version;
-  }
-
-  return verNum;
-}
-/**
- * 格式化上报数据
- * @private
- * @param {object} reportData 需要上报的数据
- * @param {object} deviceData 设备数据(系统信息，网络状况，位置信息)
- * @returns {array} 格式化后的上报数据
- */
-
-
-const formatReportData = async (reportData, deviceData) => {
-  const [system, netType, provinceInfo] = deviceData;
-  const param = Array.isArray(reportData.param) ? reportData.param : getReportDataList(reportData);
-  const {
-    client
-  } = await getTMS().getEnvInfo();
-  param[5] = await getUserId();
-  param[10] = getMiniProgramVersion(); // 上报小程序版本号
-
-  param[16] = getLaunchFrom(); // 渠道公共参数
-
-  param[17] = param[17] || (provinceInfo === null || provinceInfo === void 0 ? void 0 : provinceInfo.province);
-  param[18] = param[18] || (provinceInfo === null || provinceInfo === void 0 ? void 0 : provinceInfo.cityName);
-  param[19] = system === null || system === void 0 ? void 0 : system.host; // 上报宿主app信息 { appId, env, version }
-
-  param[28] = client; // 默认上报数据
-
-  const defaultReportData = {
-    9: '2',
-    12: netType,
-    13: '2',
-    29: getAppShowOptions().scene,
-    // 打开小程序的场景值
-    33: JSON.stringify(system),
-    // 数据字符串化
-    36: getAppShowOptions() // 打开小程序的场景值及参数
-
-  }; // 对部分空数据使用默认数据填充
-
-  const handleDefaultData = (paramItem, defaultData) => {
-    const arr = [paramItem, paramItem === 0, paramItem === false];
-    return arr.some(item => !!item) ? paramItem : defaultData || '';
-  };
-
-  Object.keys(defaultReportData).forEach(index => {
-    const paramItem = param[index];
-    param[index] = handleDefaultData(paramItem, defaultReportData[index]);
-  }); // 所有上报数据都转换为字符串
-
-  param.forEach((reportItem, index) => {
-    if (reportItem && typeof reportItem !== 'string') {
-      param[index] = `${JSON.stringify(reportItem)}`;
-    } else {
-      param[index] = handleDefaultData(reportItem, '');
-    }
-  });
-  return param.map(item => item !== null ? encodeURIComponent(item) : item);
-};
-/**
- * 格式化上报到小程序后台的数据(自定义分析使用)
- * @private
- * @param {array} data 埋点数据
- * @returns {object} 格式化的数据
- */
-
-
-const formatAnalyticsData = async data => {
-  const analyticsData = {};
-  const {
-    10: version,
-    29: scene
-  } = data;
-  analyticsData[10] = version; // 小程序版本号
-
-  analyticsData[29] = scene; // 小程序场景值
-
-  analyticsData[17] = decodeURIComponent(data[17]); // 用户所在省份
-
-  analyticsData[18] = decodeURIComponent(data[18]); // 用户所在城市
-  // 将30-40位埋点字段补充到上报数据中
-
-  for (let i = 30; i < 41; i += 1) {
-    analyticsData[i] = decodeURIComponent(data[i] || ''); // 如果第33列是设备信息，则忽略
-
-    if (data[33] && data[33].indexOf('model') > -1) {
-      analyticsData[33] = '';
-    }
-  }
-
-  const {
-    client
-  } = await getTMS().getEnvInfo();
-  return {
-    analyticsData,
-    eventName: `${client}_${data[27]}`
-  };
-};
-/**
- * 上报数据到小程序后台
- * @private
- * @param {array} list 需要上报的数据列表
- * @returns {void}
- */
-
-
-const reportAnalytics = (list = []) => {
-  try {
-    list.forEach(item => {
-      const {
-        eventName,
-        analyticsData
-      } = formatAnalyticsData(item);
-      wx.reportAnalytics(eventName, analyticsData);
-    });
-  } catch (_) {}
-};
-/**
- * @description report 方法 将上报数据缓存到内存中
- * @name report
- * @param {object} reportData 需要上报的数据
- * @param {boolean} reportNow 是否立即上报
- * @param {boolean} locPoi 是否通过微信接口获取poi
- * @returns {Void} 无返回值
- */
-
-
-const cache = (reportData, reportNow, locPoi = true) => {
-  // 如果是微信爬虫 | 自动化测试场景，则不进行数据上报
-  const DO_NOT_NEED_REPORT_SCENES = [1030, 1129];
-
-  if (DO_NOT_NEED_REPORT_SCENES.includes(getAppShowOptions().scene)) {
-    return Promise.resolve();
-  }
-
-  const task = [getSystemPromise(), getNetworkType()];
-
-  if (locPoi) {
-    task.push(getProvinceInfo());
-  } else {
-    task.push(getProvinceInfoByIp());
-  }
-
-  return Promise.all(task).then(async deviceData => {
-    // 先对上报数据进行预处理
-    const result = await formatReportData(reportData, deviceData); // 将需要上报的数据缓存在队列中
-
-    ReportDataQueue.push(result);
-  }).then(() => {
-    if (reportNow) {
-      return sendData();
-    }
-
-    return {
-      cache: true
-    };
-  });
-};
-/**
- * 发送数据到服务端
- * @private
- * @returns {promise} 发送请求
- */
-
-
-const sendData = async () => {
-  // 没有数据时，不发送上报请求
-  if (ReportDataQueue.length === 0) {
-    return Promise.resolve();
-  }
-
-  const cacheReportData = [...ReportDataQueue];
-  return R.post('basic/event/upload', {
-    userId: await getUserId(),
-    batch: cacheReportData
-  }).then((res = {}) => {
-    const {
-      errCode
-    } = res || {}; // 已经发送成功，则将本次发送的数据从数据队列中删除
-
-    if (errCode === 0) {
-      ReportDataQueue.splice(0, cacheReportData.length);
-      reportAnalytics(cacheReportData); // 将数据上报至小程序后台
-    }
-  });
-};
-/**
- * 开启轮询上报定时器
- * @private
- * @param {boolean} clearTimerAfterSend 是发送完数据后否清除定时器标识
- * @returns {void}
- */
-
-
-const startSendTimer = clearTimerAfterSend => {
-  ReportTaskId = setInterval(async () => {
-    sendData();
-
-    if (clearTimerAfterSend) {
-      clearInterval(ReportTaskId);
-    }
-  }, ReportInterval);
-};
-/**
- * 停止定时器
- * @private
- * @returns {void}
- */
-
-
-const stopSendTimer = () => {
-  clearInterval(ReportTaskId);
-};
-/**
- * 发送上报数据到服务端
- * @private
- * @param {boolean} reportNow 是否立即上报
- * @param {boolean} clearTimerAfterSend 是否发送之后清除定时器
- * @returns {void}
- */
-
-
-const report = (reportNow = false, clearTimerAfterSend = false) => {
-  if (reportNow) {
-    if (ReportDataQueue.length > 0) {
-      sendData();
-    }
-
-    if (!clearTimerAfterSend) {
-      startSendTimer(clearTimerAfterSend);
-    } else {
-      stopSendTimer();
-    }
-  } else {
-    startSendTimer(clearTimerAfterSend);
-  }
-};
-/**
- * 更新小程序onShow参数
- * @private
- * @param {object} options 小程序onShow参数
- * @returns {void}
- */
-
-
-const setAppShowOptions = options => {
-  appShowOptions = options;
-};
-/**
- * init之后再监听
- */
-
-
-const startListenApp = () => {
-  /**
-   * 监听小程序onShow事件
-   * @private
-   */
-  wx.onAppShow(options => {
-    // 更新onShow参数
-    setAppShowOptions(options); // 上报数据
-
-    report(true);
-  });
-  /**
-   * 监听小程序onHide事件
-   * @private
-   */
-
-  wx.onAppHide(() => {
-    // onHide时立即上报，并清除定时器
-    report(true, true);
-  });
-};
-
-/**
- * 四舍五入（支持保留n位小数，n>=0）
- * @param {any} x 原数字
- *                如果n不是合法数字或者无法转换为合法数字，round结果返回NaN
- * @param {any} n 保留几位小数，默认0
- *                如果n不是合法数字或者无法转换为合法数字，round结果返回NaN
- *                如果n小于0，round结果返回NaN
- *                如果n的值包含小数部分，round处理时只关注n的整数部分值
- * @return {number} 返回一个保留n位小数的数字，异常情况下可能是NaN
- */
-
-const round = (x, n = 0) => parseFloat(roundStr(x, n, false));
-
-/**
- * 支持服务接入相关接口
- */
-/**
- * getMpOpenId 获取接入方用户唯一标识 [变更为 getOuterOpenId]
- * @private
- * @description 唯一标识 openId 用于与服务商建立账号关联关系
- * @category 服务接入
- * @param {String} mpId 接入服务商渠道标识
- * @param {String} userId 出行用户标识
- * @returns {Promise<String>} 返回 openId，失败时返回空
- */
-
-async function getMpOpenId(mpId, userId) {
-  const {
-    resData
-  } = await new Request().post('user/mpinfo', {
-    userId,
-    mpId
-  });
-  const {
-    openId = ''
-  } = resData || {};
-  return openId;
-}
-/**
- * getOuterOpenId 获取接入方用户唯一标识
- * @public
- * @description 唯一标识 openId 用于服务接入方作为唯一标识、向腾讯出行服务同步订单等
- * @category 服务接入
- * @param {String} apiKey 服务接入方渠道标识
- * @returns {Promise<String>} 返回 openId，失败时返回空
- */
-
-
-async function getOuterOpenId(apiKey) {
-  const {
-    resData
-  } = await new Request().post('user/mpinfo', {
-    mpId: apiKey
-  });
-  const {
-    openId = ''
-  } = resData || {};
-  return openId;
-}
-
-/**
- * @public
- * @description 创建网络请求对象，用于向腾讯出行服务平台后台发送网络请求
- * @param {Object} [config] 参数配置
- * @param {Boolean} [config.withAuth=true] 是否填充登录态参数
- * @param {String} [config.host] 自定义的host域名
- * @param {Object} [config.baseParam] 默认携带的参数
- * @returns {Object} [Request实例](#class-request)
- * @example
- * const $ = getApp().tms.createRequest();
- * $.get(apiPath)
- *   .then((resp) => {
- *     // ...
- *   })
- *   .catch((err) => {
- *     // ...
- *   });
- */
-
-const createRequest = (config = {}) => new Request(config);
-/**
- * @description 埋点上报
- * @returns {Object} 包含[report方法](#report)的对象
- * @example
- * getReporter().report(reportData, reportNow);
- */
-
-
-const getReporter = () => ({
-  report: cache
-});
-/**
- * @description 埋点上报(快速上报，不依赖用户userId标识)
- * @returns {Class} [FastReporter类](#class-fastreport)
- */
-
-
-const getFastReporter = () => FastReport;
-/**
- * @description 自定义事件机制
- * @returns {Object} [EventDispatcher实例](#class-eventdispatcher)
- */
-
-
-const getEventDispatcher = () => new EventDispatcher();
-/**
- * @description 获取地理位置方法的集合
- * @returns {Class} [Location类](#class-location)
- */
-
-
-const getLocationManager = () => getLocInstance();
-/**
- * @description 获取位置信息base类(业务无关)
- * @returns {Class} [Location类](#class-location)
- */
-
-
-const getLocationBaseClass = () => LocationBase$1;
-/**
- * @description init core包初始化, 小程序已在app.js中对齐初始化
- * @param {Object} options 初始化
- * @returns {undefined} 无返回值.
- */
-
-
-const init = (options = {}) => {
-  startListenApp();
-  const {
-    appVersion,
-    wxAppId,
-    client,
-    defaultHost,
-    cloudEnvId,
-    appEnv,
-    appPagePaths,
-    homePage
-  } = options;
-  setEnvInfo({
-    wxAppId,
-    appVersion,
-    appEnv,
-    client,
-    cloudEnvId
-  });
-  setAppPagePaths(appPagePaths, homePage);
-  Request.defaultHost = defaultHost; // 初始化云环境
-
-  wx.cloud.init({
-    env: cloudEnvId
-  });
-};
-/**
- * @description 获取用户位置信息 -- 兼容版 现有业务中有的使用promise， 有的没有， 做一下兼容
- * @returns { Promise } 位置信息
- */
-
-
-const getUserLocation = () => {
-  const userLocation = getLocInstance().getUserLocation();
-
-  if (userLocation) {
-    return Promise.resolve(userLocation);
-  }
-
-  return getLocInstance().getLocationDetail(false);
-};
-
-const api = {
-  init,
-  createRequest,
-  setAuthInfo,
-  getLogManager,
-  getRealtimeLogManager,
-  md5,
-  getReporter,
-  getFastReporter,
-  getLocationManager,
-  getLocationBaseClass,
-  getEventDispatcher,
-  getEnvInfo,
-  getConfig,
-  navigateToWebview: nav.navigateToWebview,
-  isAppPageExist,
-  getHomePage,
-  callCloudFunc,
-  setUserLocation: loc => {
-    getLocInstance().setUserLocation(loc);
-  },
-  getUserLocation,
-
-  /* 字符串方法 */
-  formatPlate,
-  subStr,
-  hidePhoneCenter,
-  isValidPhone,
-  isValidPlate,
-  isValidAuthCode,
-  roundStr,
-
-  /* 数字方法 */
-  round,
-
-  /* 时间方法 */
-  formatTime,
-  formatTimeStr,
-  formatTimeWithDetails,
-  dateToString,
-
-  /* IPX方法 */
-  ipxInit,
-  isIPX,
-  getIpxClass,
-  getIpxConfig,
-
-  /* 处理对象方法 */
-  serialize,
-
-  /* 获取外部合作商openid */
-  getMpOpenId,
-  // 变更为 getOuterOpenId
-  getOuterOpenId,
-
-  /** rpx转px */
-  rpxToPx,
-  storage,
-  ...syncApi
-};
-
-export { api as default };