@tmsfe/tms-core 0.0.82 → 0.0.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tmsfe/tms-core",
-  "version": "0.0.82",
+  "version": "0.0.85",
   "description": "tms运行时框架",
   "repository": {
     "type": "git",
@@ -18,19 +18,19 @@
     ]
   },
   "devDependencies": {
-    "@babel/core": "^7.15.0",
+    "@babel/core": "^7.17.9",
     "@babel/plugin-proposal-class-properties": "^7.14.5",
     "@babel/plugin-proposal-nullish-coalescing-operator": "^7.14.2",
-    "@babel/plugin-proposal-optional-chaining": "^7.14.2",
+    "@babel/plugin-proposal-optional-chaining": "^7.14.5",
     "@rollup/plugin-babel": "^5.0.2",
     "@rollup/plugin-commonjs": "^19.0.0",
     "@rollup/plugin-dynamic-import-vars": "^1.1.1",
     "@rollup/plugin-json": "^4.0.3",
-    "@typescript-eslint/eslint-plugin": "^4.29.3",
-    "@typescript-eslint/parser": "^4.29.3",
+    "@typescript-eslint/eslint-plugin": "^5.2.0",
+    "@typescript-eslint/parser": "^5.2.0",
     "babel-core": "^6.26.3",
     "babel-preset-env": "^1.7.0",
-    "miniprogram-api-typings": "^3.4.4",
+    "miniprogram-api-typings": "latest",
     "rimraf": "^3.0.2",
     "rollup": "^2.6.1",
     "rollup-plugin-node-resolve": "^5.2.0",

package/src/utils/authUtils/index.js

@@ -0,0 +1,96 @@
+// @copyright 2020-present, Tencent, Inc. All rights reserved.
+// @author Fenggang.Sun <fenggangsun@tencent.com>
+// @file 微信授权工具方法
+
+// 微信权限列表
+// 此处列出当前小程序中有使用的权限，全量scope请参考：https://developers.weixin.qq.com/miniprogram/dev/framework/open-ability/authorize.html
+const scope = {
+  writeAlbum: 'scope.writePhotosAlbum', // 添加到相册
+};
+
+const scopeName = {
+  [scope.writeAlbum]: '保存到相册',
+};
+
+/**
+ * 获取当前授权状态
+ * @param {String} authScope  权限scope
+ * @returns {Promise<Object>} 成功获取授权状态时，Promise被resolved，Object.authed字段表示授权状态
+ *                            授权授权状态出现异常时，Promise被rejected
+ *   Object.authed: true-已授权，false-拒绝授权，undefined-未发起过授权动作
+ */
+const getAuthStatus = authScope => new Promise((resolve, reject) => wx.getSetting({
+  success: res => resolve({ authed: res.authSetting[authScope] }),
+  fail: reject,
+}));
+
+/**
+ * 引导用户在设置页面打开授权，获取引导授权结果
+ * @param {String} authScope  权限scope
+ * @param {Object}  guideModal              授权弹窗相关配置
+ * @param {String}  guideModal.title        标题
+ * @param {String}  guideModal.content      文案内容
+ * @param {Boolean} guideModal.showCancel   是否展示取消按钮
+ * @param {String}  guideModal.cancelText   取消按钮文案
+ * @param {String}  guideModal.cancelColor  取消按钮文案颜色
+ * @param {String}  guideModal.confirmText  确定按钮文案
+ * @param {String}  guideModal.confirmColor 确定按钮文案颜色
+ * @returns {Promise<Object>} 引导授权流程正常执行结束，Promise被resolved，Object.authed字段表示授权状态
+ *                            引导流程出现异常时，Promise被rejected
+ *   Object.authed: true-已授权，false-拒绝授权，undefined-未发起过授权动作
+ */
+const guideAuth = (authScope, guideModal) => new Promise((resolve, reject) => {
+  const {
+    title = '', content,
+    showCancel = true, cancelText = '取消', cancelColor = '#000000',
+    confirmText = '现在去', confirmColor,
+  } = guideModal || {};
+  const contentText = content || `监测到您没有授权${scopeName[authScope] || '相关'}权限，无法使用该功能，是否去授权？`;
+  wx.showModal({
+    title, content: contentText,
+    showCancel, cancelText, cancelColor,
+    confirmText, confirmColor,
+    success: (res) => {
+      if (!res.confirm) return resolve({ authed: false, confirm: res.confirm }); // 用户拒绝去授权
+      wx.openSetting({ // 跳转到授权页面进行授权
+        success: ({ authSetting }) => resolve({ authed: authSetting[authScope], confirm: true }), // 确认授权结果
+        fail: reject,
+      });
+    },
+    fail: reject,
+  });
+});
+
+/**
+ * 发起授权，获取授权结果
+ * 如果是首次授权，拉起底部授权弹窗；授权失败后引导用户进入设置完成授权
+ * 如果不是首次授权，直接引导用户进入设置页完成授权
+ * @param {String} authScope  权限scope
+ * @param {Object}  guideModal              授权弹窗相关配置
+ * @param {String}  guideModal.title        标题
+ * @param {String}  guideModal.content      文案内容
+ * @param {Boolean} guideModal.showCancel   是否展示取消按钮
+ * @param {String}  guideModal.cancelText   取消按钮文案
+ * @param {String}  guideModal.cancelColor  取消按钮文案颜色
+ * @param {String}  guideModal.confirmText  确定按钮文案
+ * @param {String}  guideModal.confirmColor 确定按钮文案颜色
+ * @returns {Promise<Object>} 授权流程正常执行结束，Promise被resolved，Object.authed字段表示授权状态
+ *                            授权流程出现异常时，Promise被rejected
+ *   Object.authed: true-已授权，false-拒绝授权，undefined-未发起过授权动作
+ */
+const auth = (authScope, guideModal) => new Promise((resolve, reject) => wx.authorize({ // 如果从未授权，此时会拉起一个授权
+  scope: authScope,
+  success: () => resolve({ authed: true }), // 授权成功
+  fail: () => guideAuth(authScope, guideModal) // 授权失败，引导用户在设置页完成授权
+    .then(resolve)
+    .catch(reject),
+}));
+
+const api = {
+  scope,
+  getAuthStatus,
+  guideAuth,
+  auth,
+};
+
+module.exports = api;

package/src/utils/canvas/canvasDrawer.js

@@ -0,0 +1,289 @@
+class CanvasDrawer {
+  constructor(canvasId, container, instance = '', designWindowWidth = 750) {
+    this.canvasId = canvasId; // canvasId
+    this.container = container; // 海报图容器参数 {bgColor, radius}
+    this.compInstance = instance; // 组件中使用需传入组件实例
+    this.designWindowWidth = designWindowWidth; // 设计稿尺寸, 默认750
+  }
+
+  init() {
+    return new Promise((resolve, reject) => {
+      const query = (this.compInstance || wx).createSelectorQuery();
+      query.select(this.canvasId)
+        .fields({ node: true, size: true })
+        .exec((res) => {
+          if (!res?.[0]?.node) reject('No canvas element found');
+          const canvas = res[0].node;
+          this.canvas = canvas;
+          this.ctx = canvas.getContext('2d');
+          const { pixelRatio: dpr, windowWidth } = wx.getSystemInfoSync();
+          canvas.width = res[0].width * dpr;
+          canvas.height = res[0].height * dpr;
+          this.ratio = windowWidth / this.designWindowWidth;
+          this.ctx.scale(dpr, dpr);
+          // 海报图宽高自动获取画布宽高
+          this.container.width = res[0].width / this.ratio;
+          this.container.height = res[0].height / this.ratio;
+          // 绘制海报图容器
+          this.drawRectContainer(this.container);
+          resolve();
+        });
+    });
+  }
+
+  toPx(rpx) {
+    return rpx * this.ratio;
+  }
+
+  /**
+   *  绘制矩形容器
+   * @param {*} [{ x, y, bgColor, width, height, radius, type }={}] 背景 宽 高 圆角 线/填充
+   */
+  drawRectContainer({ x = 0, y = 0, bgColor, width, height, radius, type = 'fill' } = {}) {
+    this.drawRect(x, y, width, height, radius, bgColor, type);
+    this.ctx.clip();
+  }
+
+  // 绘制矩形
+  drawRect(x, y, w, h, radius, color, type = 'fill') {
+    // eslint-disable-next-line no-param-reassign
+    x = this.toPx(x); y = this.toPx(y); w = this.toPx(w); h = this.toPx(h);
+    this.ctx.save();
+    const { ctx } = this;
+    const rad = this.toPx(radius) || 0;
+    ctx.beginPath();
+    ctx.moveTo(x, y + rad);
+    ctx.lineTo(x, y + h - rad);
+    ctx.quadraticCurveTo(x, y + h, x + rad, y + h);
+    ctx.lineTo(x + w - rad, y + h);
+    ctx.quadraticCurveTo(x + w, y + h, x + w, y + h - rad);
+    ctx.lineTo(x + w, y + rad);
+    ctx.quadraticCurveTo(x + w, y, x + w - rad, y);
+    ctx.lineTo(x + rad, y);
+    ctx.quadraticCurveTo(x, y, x, y + rad);
+    ctx[`${type}Style`] = color;
+    ctx.closePath();
+    ctx[type]();
+    this.ctx.restore();
+  }
+
+  // 绘制圆形
+  drawCircular(x, y, r, color = '#ffffff', type = 'fill') {
+    const { ctx } = this;
+    ctx.beginPath();
+    ctx.arc(this.toPx(x + r), this.toPx(y + r), this.toPx(r), 0, 2 * Math.PI);
+    ctx.closePath();
+    ctx[`${type}Style`] = color;
+    ctx[type]();
+  }
+
+  /**
+   * 绘制图片
+   *
+   * @param {*} src
+   * @param {*} x
+   * @param {*} y
+   * @param {*} width
+   * @param {*} height
+   * @param {*} round 是否切成圆形图片
+   * @param {*} borderwidth 圆形模式下边框宽度
+   * @param {*} borderColor 圆形模式下边框颜色
+   * @returns
+   * @memberof Wxml2Poster
+   */
+  drawImage(src, x, y, width, height, round, borderwidth = 0, borderColor = '#ffffff') {
+    return new Promise((resolve, reject) => {
+      const img = this.canvas.createImage();
+      img.onerror = reject;
+      img.src = src;
+      img.onload = () => {
+        this.ctx.save();
+        if (round) {
+          const r = (width / 2) + borderwidth; // 半径
+          this.drawCircular(x - borderwidth, y - borderwidth, r, borderColor);
+          this.ctx.clip();
+        }
+        this.ctx.drawImage(img, this.toPx(x), this.toPx(y), this.toPx(width), this.toPx(height));
+        this.ctx.restore();
+        resolve();
+      };
+    });
+  };
+
+  /**
+   * 绘制文本
+   *
+   * @param {*} text 文本字符串
+   * @param {*} x 横坐标位置
+   * @param {*} y 纵坐标位置
+   * @param {*} size  字体大小
+   * @param {*} color 字体颜色
+   * @param {string} [align='left'] 对齐方式 left(x值不包含字体宽度), center(x值包含一半字体宽度), right(x值包含整个字体宽度)
+   * @param {string} [bold='normal'] 字重，值同css font-weight
+   * @param {string} [baseLine='middle'] top(y值不包含字体高度), middle(y值包含一半字体高度)，bottom(y值包含整个字体高度)
+   * @returns 文本占用宽度
+   * @memberof Wxml2Poster
+   */
+  drawText(text, x, y, size, color, align = 'left', bold = 'normal', baseLine = 'middle', calWidth = false) {
+    const str = `${text}`;  // 避免某些环境下字体宽度计算异常（如手图），这里统一将绘制文本转为字符串
+    this.ctx.save();
+    this.ctx.fillStyle = color;
+    this.ctx.font = `normal ${bold} ${~~(this.toPx(size))}px sans-serif`;
+    let width = 0;
+    if (calWidth) width = this.ctx.measureText(str).width; // 必须在设置字体属性后未绘制前计算才能拿到准确值; 无需计算时避免耗费性能
+    this.ctx.textAlign = align;
+    this.ctx.textBaseline = baseLine;
+    this.ctx.fillText(str, this.toPx(x), this.toPx(y));
+    this.ctx.restore();
+    return width;
+  }
+
+  /**
+   * 绘制文本并返回文本占用宽度
+   *
+   * @param {*} text 文本字符串
+   * @param {*} x 横坐标位置
+   * @param {*} y 纵坐标位置
+   * @param {*} size  字体大小
+   * @param {*} color 字体颜色
+   * @param {string} [align='left'] 对齐方式 left(x值不包含字体宽度), center(x值包含一半字体宽度), right(x值包含整个字体宽度)
+   * @param {string} [bold='normal'] 字重，值同css font-weight
+   * @param {string} [baseLine='top'] top(y值不包含字体高度), middle(y值包含一半字体高度)，bottom(y值包含整个字体高度)
+   * @returns {number} width 文本占用宽度
+   * @returns {number} x 横坐标位置
+   * @memberof Wxml2Poster
+   */
+  drawTextWithWidth(text, x, y, size, color, align = 'left', bold = 'normal', baseLine = 'top') {
+    const width = this.drawText(text, x, y, size, color, align, bold, baseLine, true);
+    return {
+      width: width / this.ratio,
+      x,
+    };
+  }
+
+  /**
+   * 绘制由动态文本组成的行
+   * 可传入要绘制的文本数组或文本属性数组
+   * 若该行文本样式一致时直接传入文本数组即可
+   * 若需要个性化单个文本可传入文本属性数组
+   * 个性化属性未填写时默认使用全局属性
+   *
+   * @param {Object}   textObj - 文本对象
+   * @param {string[]|Object[]} textObj.texts - 要绘制的文本数组或文本属性数组
+   * @param {string}   textObj.texts[].text - 要绘制的文本
+   * @param {number}   textObj.texts[].textMargin - 文本间距
+   * @param {number}   textObj.texts[].size - 字体大小
+   * @param {string}   textObj.texts[].color - 字体颜色
+   * @param {string}   textObj.texts[].bold - 字重
+   * @param {string}   textObj.texts[].originY - 起始y
+   * @param {number}   textObj.originX - 起始x
+   * @param {number}   textObj.originY - 起始y
+   * @param {number}   textObj.textMargin - 文本间距
+   * @param {number}   textObj.size - 字体大小
+   * @param {string}   textObj.color - 字体颜色
+   * @param {string}   textObj.bold - 字重
+   * @memberof CanvasDrawer
+   */
+  drawDynamicTextsRow({ texts = [], originX = 0, originY, textMargin = 0, size, color, bold = 'normal' } = {}) {
+    texts.reduce((totalX, item) => {
+      let text = item; let oy = originY; let tm = textMargin; let cl = color; let sz = size; let bl = bold;
+      if (typeof item === 'object') {
+        text = item.text;
+        oy = item.originY || originY;
+        tm = item.textMargin || textMargin;
+        cl = item.color || color;
+        sz = item.size || size;
+        bl = item.bold || bold;
+      }
+      const { width } = this.drawTextWithWidth(text, totalX, oy, sz, cl, 'left', bl, 'top');
+      return totalX + width + tm;
+    }, originX);
+  }
+
+  /**
+   * 批量绘制文本
+   * @param {Object[]} texts 文字数组
+   * @param {Object} texts[i], 文字属性 { text, x, y, size, color, align = 'left', bold = 'normal', baseLine = 'middle' }
+   */
+  drawTexts(texts) {
+    texts.forEach((item) => {
+      const { text, x, y, size, color, align = 'left', bold = 'normal', baseLine = 'middle' } = item;
+      this.drawText(text, x, y, size, color, align, bold, baseLine);
+    });
+  }
+
+  // 获取相册权限
+  getAlbumAuth() {
+    return new Promise((resolve, reject) => {
+      wx.getSetting({
+        success(res) {
+          if (res.authSetting['scope.writePhotosAlbum']) return resolve();
+          wx.authorize({
+            scope: 'scope.writePhotosAlbum',
+            success: () => resolve(),
+            fail: () => {
+              reject();
+              wx.showModal({
+                title: '',
+                content: '监测到您没有授权保存到相册权限,无法使用该功能,是否去授权',
+                showCancel: true,
+                cancelText: '取消',
+                cancelColor: '#000000',
+                confirmText: '现在去',
+                success: (result) => {
+                  if (result.confirm) wx.openSetting();
+                },
+              });
+            },
+          });
+        },
+      });
+    });
+  }
+
+  // 保存图片(可选自定义toast)
+  saveImage({ customSuccToast = false, customFailToast = false } = {}) {
+    return new Promise((resolve, reject) => {
+      if (!this.tempFilePath) {
+        wx.showToast({ title: '海报未准备好，请稍等', icon: 'none' });
+        reject('资源还未绘制完成');
+      };
+      this.getAlbumAuth().then(() => {
+        wx.saveImageToPhotosAlbum({
+          filePath: this.tempFilePath,
+          success: () => {
+            !customSuccToast && wx.showToast({ title: '保存成功', icon: 'success', duration: 2000 });
+            resolve(this.tempFilePath);
+          },
+          fail: () => {
+            !customFailToast && wx.showToast({ title: '保存失败，请重试', icon: 'none' });
+            reject('取消保存');
+          },
+        });
+      });
+    });
+  }
+
+  // 导出画布(先导出，再saveImage)
+  canvasExport() {
+    return new Promise((resolve, reject) => {
+      wx.canvasToTempFilePath({
+        canvas: this.canvas,
+        success: (res) => {
+          this.tempFilePath = res.tempFilePath;
+          resolve(res.tempFilePath);
+        },
+        fail: () => {
+          reject();
+        },
+      }, this.compInstance);
+    });
+  }
+
+  // 获取画布导出状态
+  getExportStatus() {
+    return !!this.tempFilePath;
+  }
+}
+
+export default CanvasDrawer;

package/src/utils/carCard/Comm.js

@@ -0,0 +1,61 @@
+class Common {
+  // 获取本月开始时间
+  static getMonthStart() {
+    const now = new Date();             // 获取当前时间
+    const beginTimes = now.getFullYear();     // 开始计算
+    let month = now.getMonth() + 1 ;           // getMonth()是以0开始的月份
+    if (month < 10) {
+      month = `0${month}`;
+    }
+    const startTimes = `${beginTimes}-${month}-01`;        // 格式 Y-m-d
+    return startTimes;
+  }
+
+  static pointToYuan(num) {
+    if (!num || num <= 0) {
+      return 0;
+    }
+    const { tms } = getApp({ allowDefault: true });
+    return tms.roundStr(num / 100, 0);
+  }
+
+  static handleApiRes(res) {
+    let { errCode, errMsg, resData } = res;
+    // 兼容后端返回err、info作为字段的情况
+    // eslint-disable-next-line
+    if (resData?.data?.hasOwnProperty('err')) {
+      errCode = resData.data.err;
+      errMsg = resData.data.info;
+      resData = resData.data;
+      if (errCode !== 0) {
+        return Promise.reject({ errCode, errMsg, resData });
+      }
+      return Promise.resolve(resData);
+    }
+    if (errCode !== 0) {
+      return Promise.reject(res);
+    }
+    return Promise.resolve(resData);
+  }
+
+  static handleConditionValue(item, value) {
+    if (isNaN(value)) {
+      return { value, units: item.units };
+    }
+    let newValue = value;
+    let { units } = item;
+    // 小数点处理
+    if (item.point === 0) {
+      newValue = Math.round(newValue);
+    }
+    if (item.point) {
+      newValue = parseFloat(newValue.toFixed(item.point));
+    }
+    if (newValue > 9999) {
+      newValue = `${(newValue / 10000).toFixed(1)}`;
+      units = `万${item.units}`;
+    }
+    return { value: newValue, units };
+  }
+}
+export default Common;

package/src/utils/carCard/Controller.js

@@ -0,0 +1,91 @@
+import m from './Model';
+import Comm from './Comm';
+
+export default class Controller {
+  static report = m.report;
+  static carManager = m.carManager;
+  static getConfig = m.getConfig;
+  static locManager = m.locManager;
+  static rtLog = m.rtLog;
+  static dateToString = m.dateToString;
+  static log = m.log;
+
+  // 通用的埋点方法
+  // wecarId seriesId modelId必传
+  static commReport(currentCar = {}, param = {}) {
+    const { wecarId = '', seriesId = 0, modelId = 0  } = currentCar;
+    // console.log('我要埋点了', param['27'], { 4: wecarId, 39: seriesId, 30: modelId, ...param });
+    return Controller.report({ 4: wecarId, 39: seriesId, 30: modelId, ...param });
+  }
+
+  // 车辆本月etc账单
+  static async getETCAmount(currentCar) {
+    const { plate, wecarId, userId, plateColor } = currentCar;
+    const param = { userId, plateNum: plate, wecarId };
+    let result = { etcData: {} };
+    try {
+      const { data } = await m.queryEtcBindStatus(param) || {};
+      if (!data || data.etcStatus !== 1) {
+        result.isBindEtc = false;
+        return result;
+      }
+    } catch (error) {
+      result.isBindEtc = false;
+      return result;
+    }
+
+    try {
+      const param2 = { plateColor, dateBegin: Comm.getMonthStart(), dateEnd: Controller.dateToString() };
+      Object.assign(param, param2);
+      const res = await m.queryEtcMount(param) || {};
+      result = {
+        isBindEtc: true,
+        getEtcDataError: false,
+      };
+      if (res.totalAmount > 0) {
+        result.etcData = { ...res, totalAmount: Comm.pointToYuan(res.totalAmount) };
+      } else {
+        result.etcData = { };
+      }
+    } catch (error) {
+      result = {
+        isBindEtc: true,
+        getEtcDataError: true,
+      };
+    }
+    return result;
+  }
+
+  // 获取车况配置
+  static async getCarConditionConfig(param) {
+    let data = {};
+    try {
+      data = await m.getCarConditionConfig(param);
+    } catch (err) {
+      m.log({ name: 'getCarConditionConfig', param, err });
+    }
+    return data;
+  }
+
+  // 获取车控配置
+  static async getCarControlConfig(param) {
+    let data = {};
+    try {
+      data = await m.getCarControlConfig(param);
+    } catch (err) {
+      m.log({ name: 'getCarControlConfig', param, err });
+    }
+    return data;
+  }
+
+  // 获取车况
+  static async getGactoyotaCondition(param) {
+    let data = {};
+    try {
+      data = await m.getGactoyotaCondition(param);
+    } catch (err) {
+      m.log({ name: 'getGactoyotaCondition', param, err });
+    }
+    return data;
+  }
+};

package/src/utils/carCard/Model.js

@@ -0,0 +1,52 @@
+import Comm from './Comm';
+const app = getApp({ allowDefault: true });
+
+export default class Model {
+  static report = app.tms.getReporter().report;
+  static carManager = app.tms.getCarManager();
+  static getConfig = app.tms.getConfig;
+  static locManager = app.tms.getLocationManager();
+  static rtLog = app.tms.getRealtimeLogManager();
+  static dateToString = app.tms.dateToString;
+
+  static doRequest(path, param, method = 'POST', header) {
+    return app.tms.createRequest().doRequest(path, { ...param }, method, header)
+      .then(res => Comm.handleApiRes(res))
+      .catch(err => Promise.reject(err));
+  }
+
+  static log(...args) {
+    console.error(...args);
+    Model.rtLog.info(args[0]);
+  }
+
+  // 获取车况数据
+  // static getGactoyotaCondition(param) {
+  //   return Model.doRequest('gactoyota/condition', { ...param }, 'POST');
+  // }
+  static getGactoyotaCondition(param) {
+    return Model.doRequest('carcardvinfosvc/get_car_condition', { ...param }, 'POST', {
+      'X-TAI-Module': 'carcardvinfosvc',
+    });
+  }
+
+  // 获取车况配置
+  static getCarConditionConfig() {
+    const app = getApp({ allowDefault: true });
+    return app.tms.getConfig('/sinan/carcondition/config');
+  }
+
+  // 获取车控配置
+  static getCarControlConfig() {
+    const app = getApp({ allowDefault: true });
+    return app.tms.getConfig('/sinan/carcontrol/config');
+  }
+
+  static queryEtcMount(param) {
+    return Model.doRequest('etc/totalamount', { ...param }, 'post');
+  }
+
+  static queryEtcBindStatus(param) {
+    return Model.doRequest('etc/querybindstatus', { ...param }, 'post');
+  }
+};

package/src/utils/flex/flex.wxss

@@ -0,0 +1,152 @@
+/* 初始化 */
+page {
+  --fontDIN: DIN Alternate;
+
+  line-height: 1.5;
+}
+
+view,
+scroll-view,
+swiper,
+button,
+input,
+textarea,
+label,
+navigator,
+image {
+  box-sizing: border-box;
+}
+
+image {
+  width: 100%;
+  height: 100%;
+}
+
+input {
+  width: 100%;
+}
+
+/* 隐藏scroll-view的滚动条 */
+::-webkit-scrollbar {
+  width: 0;
+  height: 0;
+  color: transparent;
+}
+
+/* flex布局样式 */
+
+/* 水平 */
+.flex-row {
+  display: flex;
+  flex-direction: row;
+}
+
+/* 垂直 */
+.flex-col {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+}
+
+/* 横向水平居中 */
+.flex-row-hc {
+  display: flex;
+  flex-direction: row;
+  justify-content: center;
+}
+
+/* 横向垂直居中 */
+.flex-row-vc {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+}
+
+/* 横向水平垂直居中 */
+.flex-row-hvc {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+/* 纵向水平居中 */
+.flex-col-hc {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+/* 纵向垂直居中 */
+.flex-col-vc {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+}
+
+/* 纵向垂直水平居中 */
+.flex-col-vhc {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+}
+
+/* 主轴 左对齐 */
+.flex-main-left {
+  justify-content: flex-start;
+}
+
+/* 主轴 右对齐 */
+.flex-main-right {
+  justify-content: flex-end;
+}
+
+/* 主轴 边距对齐 */
+.flex-main-around {
+  justify-content: space-around;
+}
+
+/* 主轴 边界对齐 */
+.flex-main-between {
+  justify-content: space-between;
+}
+
+/* 主轴 间距对齐 */
+.flex-main-evenly {
+  justify-content: space-evenly;
+}
+
+/* 交叉轴 上对齐 */
+.flex-cross-top {
+  align-items: flex-start;
+}
+
+/* 交叉轴 下对齐 */
+.flex-cross-bottom {
+  align-items: flex-end;
+}
+
+/* 换行 */
+.flex-wrap {
+  flex-wrap: wrap;
+}
+
+/* 重置官方按钮样式 包含去掉边框和其他 */
+.resetbtn {
+  padding: 0;
+  line-height: 0;
+  background: transparent;
+  border: 0;
+}
+
+.resetbtn::after {
+  border: 0;
+}
+
+/* 超出部分出省略号 */
+.text-overflow {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  word-break: break-all;
+  white-space: nowrap;
+}

package/src/utils/location/index.js

@@ -0,0 +1,103 @@
+/**
+ * @desc: 位置工具方法语法糖
+ * @author: fenggangsun
+ * @date: 2022-06-27 11:46:25
+ * @lastEditors: fenggangsun
+ * @lastEditTime: 2022-06-29 17:34:24
+ * @copyright 2022-present, Tencent, Inc. All rights reserved.
+ */
+const defaultLoc = {
+  province: '广东省',
+  cityName: '深圳市',
+  latitude: 22.54286,
+  longitude: 114.05956,
+  cityCode: '440300',
+  adCode: '440301',
+};
+
+let locManagerCache;
+const getLocManager = () => {
+  locManagerCache ||= getApp().tms.getLocationManager();
+  return locManagerCache;
+};
+
+const locTypeEnum = { // 位置类型
+  default: 'default', // 默认位置
+  ip: 'ip', // ip位置
+  real: 'real', // 实时定位
+  userChosen: 'userChosen', // 用户首页选择城市
+  userChosenHistory: 'userChosenHistory', // 用户曾经在首页选择城市（非本次生命中期）
+};
+
+/**
+ * 按优先级获取用户位置
+ * @param {Array<String>} typeOrders 取值次序，每个值代表一种位置数据；可选值见 locTypeEnum
+ * @param {Object}  option 调用具体接口时的一些参数
+ * @param {Boolean} option.showAuth 获取实时定位时，如果未授权，是否发起授权
+ * @param {String}  option.authTip  获取实时定位，发起授权时的提示语
+ * @param {Boolean} option.ipCache  是否使用缓存的 ip 位置，默认 true；ipCache = false 时会重新发起 ip 定位
+ * @returns {Promise<Object>} { loc, locType }
+ *                              loc: { adCode, provinceCode, cityCode, province, cityName, longitude, latitude }
+ */
+const getPrioritizedLocation = async (typeOrders, option) => {
+  const { showAuth, authTip, ipCache = true } = option || {};
+  for (const locType of typeOrders) { // 按顺序获取位置
+    let getLocProm;
+    switch (locType) {
+      case locTypeEnum.default: // 默认位置
+        getLocProm = defaultLoc;
+        break;
+      case locTypeEnum.ip:
+        getLocProm = getLocManager().getIpLocation(!ipCache)
+          .then((data) => {
+            const { ad_info: { adcode, cityCode, province, city }, location: { lng, lat } } = data;
+            return {
+              adCode: adcode, cityCode, provinceCode: `${cityCode.slice(0, 4)}00`,
+              province, cityName: city, longitude: lng, latitude: lat,
+              ...data,
+            };
+          });
+        break;
+      case locTypeEnum.real: // 实时位置
+        getLocProm = getLocManager().getLocationDetail(showAuth, undefined, authTip);
+        break;
+      case locTypeEnum.userChosen: // 本次生命周期用户选择位置
+        getLocProm = getLocManager().getUserLocation();
+        break;
+      case locTypeEnum.userChosenHistory: // 历史曾经选择的位置
+        getLocProm = wx.getStorageSync('home.city');
+        break;
+      default: break;
+    }
+    const loc = await Promise.resolve(getLocProm).catch(() => null);
+    if (loc) return { loc, locType };
+  }
+  return Promise.reject('按照参数指定的类型未能获取到位置');
+};
+
+/**
+ * 按优先级获取用户位置
+ * @param {Boolean} visitedIndex 是否打开过首页
+ * @param {Object}  option 调用具体接口时的一些参数
+ * @param {Boolean} option.showAuth 获取实时定位时，如果未授权，是否发起授权
+ * @param {String}  option.authTip  获取实时定位，发起授权时的提示语
+ * @returns {Promise<Object>} { loc, locType }
+ */
+const getInitLocation = async (visitedIndex, option) => {
+  // 从首页进入当前页，按 首页选择位置 > 实时位置 > 首页缓存的用户上一次选择的位置 > 默认位置 的顺序返回位置
+  if (visitedIndex) return getPrioritizedLocation(
+    [locTypeEnum.userChosen, locTypeEnum.real, locTypeEnum.userChosenHistory, locTypeEnum.default],
+    option,
+  );
+  // 非首页进入当前页，优先使用定位信息，其次使用默认位置
+  return getPrioritizedLocation([locTypeEnum.real, locTypeEnum.default], option);
+};
+
+const api = {
+  defaultLoc,
+  locTypeEnum,
+  getInitLocation,
+  getPrioritizedLocation,
+};
+
+export default api;

package/src/utils/navigator/index.js

@@ -0,0 +1,130 @@
+// @copyright 2022-present, Tencent, Inc. All rights reserved.
+// @author Fenggang.Sun <fenggangsun@tencent.com>
+// @file 路由工具方法
+
+/**
+ * 处理链接，获取页面路径
+ * @param {String} url 原始链接
+ * @returns {String} 页面路径，开头不带'/'，后面不带query
+ */
+const getPagePath = (url) => {
+  let path = String(url);
+  const index = path.indexOf('?');
+  if (index > -1) path = path.substring(0, index);
+  return path[0] === '/' ? path.substring(1) : path;
+};
+
+/**
+ * 找到页面访问栈中的某个页面
+ * @param {String} url 目标页面路径
+ * @param {Object} matchOptions 要检查的页面加载参数；指定此参数时，历史访问页面 onLoad 参数需与 matchOptions 指定的参数相符，才会被判定为要查找的页面
+ * @returns {Object} history 历史访问页面
+ * @returns {Number} history.size 当前页面栈大小，一共打开了多少页面
+ * @returns {Number} history.targetIndex 目标页面在页面栈中的下标，-1表示没有找到目标页面，下标越小表示越靠早访问（靠近栈底）
+ * @returns {Number} history.delta 目标页面与当前页面在访问栈中的距离，-1表示未找到目标页面；可使用此字段作为navigateBack参数来回到目标页面
+ * 示例说明：假定目前页面访问栈为：[ A?x=1&y=2, B, A?x=1, A, C ]，C为当前页面，则：
+ *    findHistoryPage(A)                  => { size: 4, targetIndex: 3,  delta: 1 }
+ *    findHistoryPage(A, { x: 1 })        => { size: 4, targetIndex: 2,  delta: 2 }
+ *    findHistoryPage(A, { x: 1, y = 2 }) => { size: 4, targetIndex: 0,  delta: 4 }
+ *    findHistoryPage(A, { x: 2 })        => { size: 4, targetIndex: -1, delta: -1 }
+ *    findHistoryPage(B)                  => { size: 4, targetIndex: 1,  delta: 2 }
+ *    findHistoryPage(C)                  => { size: 4, targetIndex: 4,  delta: 0 }
+ *    findHistoryPage(D)                  => { size: 4, targetIndex: -1, delta: -1 }
+ */
+const findHistoryPage = (url, matchOptions = {}) => {
+  const pages = getCurrentPages() || [];
+  const currentPageIndex = pages.length - 1;
+  let pageIndex = -1;
+  const targetPagePath = getPagePath(url);
+  pages.some((page, index) => {
+    const pathMatch = String(page?.route) === targetPagePath;
+    if (!pathMatch) return false;
+    const keys = Object.keys(matchOptions || {});
+    if (keys.length > 0) { // 检查页面onLoad options是否符合要求
+      if (!keys.every((key) => {
+        const expt = matchOptions[key];
+        const pageOptionVal = page.options[key];
+        return String(expt) === String(pageOptionVal);
+      })) { // 页面 onLoad 参数检查不符合 matchOptions 要求
+        return false;
+      }
+    }
+    // 找到了符合要求的页面
+    pageIndex = index;
+    return true;
+  });
+  return {
+    size: pages.length,
+    targetIndex: pageIndex,
+    delta: pageIndex === -1 ? -1 : currentPageIndex - pageIndex,
+  };
+};
+
+/**
+ * 可尽量避免循环跳转的跳转方法
+ * 如果可以找到与目录页面相符的历史访问记录，直接回退到该页面；否则打开新页面
+ * @param {Object}   options            跳转参数，类似 wx.navigateTo 和 wx.navigateBack 参数
+ * @param {String}   options.url        跳转路径（非tab页），可带参数
+ * @param {Function} [options.success]  接口调用成功的回调函数
+ * @param {Function} [options.fail]     接口调用失败的回调函数
+ * @param {Function} [options.complete] 接口调用结束的回调函数（调用成功、失败都会执行）
+ */
+const navigateTo = (options, matchOptions) => {
+  const { url, success, fail, complete } = options;
+  const { delta } = findHistoryPage(url, matchOptions);
+  if (delta < 0) wx.navigateTo({ url, success, fail, complete });
+  else wx.navigateBack({ delta, success, fail, complete });
+};
+
+
+/**
+ * 可跳过栈顶指定页面的回退
+ * @param {Number}        options.delta    返回的页面数；默认1，即返回到上一页；当指定 paths 参数且栈顶有 paths 中的页面时，delta 会被重置
+ * @param {Function}      options.success  接口调用成功的回调函数
+ * @param {Function}      options.fail     接口调用失败的回调函数
+ * @param {Function}      options.complete 接口调用结束的回调函数（调用成功、失败都会执行）
+ * @param {Array<String>} paths            要跳过的页面路径
+ */
+const navigateBack = (options = {}, paths) => {
+  // 如果先选择车型再进入车信息页，返回时应跳过车型选择相关页面
+  if (!paths?.length) return wx.navigateBack(options);
+  const pages = getCurrentPages();
+  let foundPaths = 0;
+  const purePaths = paths.map(path => getPagePath(path));
+  for (let i = pages.length - 2; i >= 0; i -= 1) {
+    if (purePaths.indexOf(pages[i].route) > -1) foundPaths += 1;
+    else break;
+  }
+  wx.navigateBack({ ...options, delta: foundPaths > 0 ? foundPaths + 1 : (options.delta || 1) });
+};
+
+let homePagePath;
+const getHomePagePath = () => {
+  if (homePagePath) return homePagePath;
+  const { isTab, path, tabs } = getApp().tms.getHomePage() || {};
+  if (!isTab && path) homePagePath = path;
+  else if (isTab && tabs?.length > 0) [homePagePath] = tabs;
+  return homePagePath;
+};
+
+// 判定页面访问栈中是否有首页
+const visitedIndex = () => {
+  const homePagePath = getHomePagePath();
+  const homePageRegExp = new RegExp(homePagePath);
+  const pages = getCurrentPages();
+  return pages?.some?.((page) => {
+    let pagePath = String(page?.route);
+    if (!pagePath.startsWith('/')) pagePath = ['/', pagePath].join('');
+    return homePageRegExp.test(pagePath);
+  });
+};
+
+const api = {
+  findHistoryPage,
+  navigateTo,
+  navigateBack,
+  getHomePagePath,
+  visitedIndex,
+};
+
+module.exports = api;