@tmsfe/tms-core 0.0.59 → 0.0.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tmsfe/tms-core",
-  "version": "0.0.59",
+  "version": "0.0.62",
   "description": "tms运行时框架",
   "repository": {
     "type": "git",

package/src/index.js

@@ -25,11 +25,14 @@ import {
   round,
 } from './numUtils';
 import {
+  groupTimeDuration,
+  formatTimeDuration,
   formatTime,
   formatTimeStr,
   formatTimeWithDetails,
   formatDateTime,
   dateToString,
+  parseDateTime,
 } from './timeUtils';
 import {
   ipxInit,
@@ -157,11 +160,14 @@ const api = {
   round,
 
   /* 时间方法 */
+  groupTimeDuration,
+  formatTimeDuration,
   formatTime,
   formatTimeStr,
   formatTimeWithDetails,
   formatDateTime,
   dateToString,
+  parseDateTime,
 
   /* IPX方法 */
   ipxInit,

package/src/report/proxy/component.ts

@@ -9,6 +9,31 @@ import clone from './clone';
 
 let originalComponent: any = null;
 
+// 劫持Component的生命周期
+function proxyLifeMethod(componentName: string, componentOptions: any, methodName: string): void {
+  /* eslint-disable */
+  componentOptions.lifetimes = componentOptions.lifetimes || {};
+  let original = helper.emptyFunc;
+  const proxyMethod = function (...args: any[]): any {
+    // 生命周期函数先发埋点，避免次过程用户退出而丢失埋点
+    const data = clone.deepClone(this.data);
+    const eventName = `Component_${componentName}_${methodName}`;
+    helper.reportData(eventName, data);
+    // 执行原函数
+    return helper.executeFunc(this, original, args, helper.emptyFunc);
+  }
+  if (componentOptions.lifetimes[methodName]) {
+    original = componentOptions.lifetimes[methodName];
+    componentOptions.lifetimes[methodName] = proxyMethod;
+  } else if (componentOptions[methodName]) {
+    original = componentOptions[methodName];
+    componentOptions[methodName] = proxyMethod;
+  } else {
+    componentOptions.lifetimes[methodName] = proxyMethod;
+  }
+  /* eslint-enable */
+}
+
 // 劫持绑定事件
 function proxyBindEvent(componentName: string, methods: any, methodName: string): void {
   const original = methods[methodName];
@@ -30,7 +55,6 @@ function proxyBindEvent(componentName: string, methods: any, methodName: string)
 
 // 劫持Page
 function init(): void {
-  // @ts-ignore
   originalComponent = Component;
   // @ts-ignore
   Component = function (options: any) {
@@ -41,6 +65,7 @@ function init(): void {
       for (const name of options.tmsReportEvents) {
         proxyBindEvent(options.tmsComponentName, methods, name);
       }
+      proxyLifeMethod(options.tmsComponentName, options, 'ready');
     }
     originalComponent(options);
   };

package/src/report/proxy/page.ts

@@ -101,9 +101,7 @@ function proxyBindEvent(pageOptions: any, methodName: string): void {
 
 // 劫持Page
 function proxyPage(): void {
-  // @ts-ignore
   originalPage = Page;
-  // @ts-ignore
   Page = function (options: any) {
     // 只有tms的页面才需要上报
     if (options.tmsAutoReport) {
@@ -122,9 +120,8 @@ function proxyPage(): void {
 // 劫持导航api
 function proxyNavigateApi(api: string): void {
   // @ts-ignore
-  const owx = wx;
-  const originalApi = owx[api];
-  Object.defineProperty(owx, api, {
+  const originalApi = wx[api];
+  Object.defineProperty(wx, api, {
     writable: true,
     enumerable: true,
     configurable: true,

package/src/report/sender.ts

@@ -49,10 +49,11 @@ function batchSendData(): void {
   const request = helper.getTms().createRequest();
   request.post('basic/event/upload', { batch })
     .then((res: any) => {
-      if (res.errCode !== 0) {
-        requestFail(batch);
-      } else {
+      if (res.errCode === 0) {
         startTimer();
+      } else if (res.errMsg !== 'Invalid or expired session!') {
+        // 如果是多端登录了，就不要再发了
+        requestFail(batch);
       }
     })
     .catch((e: any) => {

package/src/timeUtils.js

@@ -7,6 +7,86 @@
  *    2017-07-26 @davislu modify.
  */
 
+import { round } from './numUtils';
+import { roundStr } from './stringUtils';
+
+/**
+ * 将时间段进行聚合计算，得出不同时间单位的计数值，例如：3601秒 -> { hour: 1, minute: 0, second: 1 }，即：1小时0分1秒
+ * @param {Number} seconds 时间段的总秒数
+ * @param {String} maxUnit 最大计数单位：second-秒，minute-分，hour-小时，day-天，month-月，year-年；默认 year
+ *                         单位大小：year > Month > day > hour > month > second
+ * @param {String} minUnit 最小计数单位：second-秒，minute-分，hour-小时，day-天，month-月，year-年；默认 second
+ * @param {Number} decimal 有不足最小单位数值的情况下，保留几位小数；默认 2
+ * @returns {Object} result 各计数单位下的数值：
+ *   {Number} result.year    - 年；  当maxUnit < 'year' 时，此字段永远为0；此字段为-1时，表示 seconds 参数非法 或 minUnit > maxUnit等异常情况
+ *   {Number} result.month   - 月；  当maxUnit < 'month' 时，此字段永远为0；
+ *   {Number} result.day     - 天；  当maxUnit < 'day' 时，此字段永远为0；
+ *   {Number} result.hour    - 小时；当maxUnit < 'hour' 时，此字段永远为0；
+ *   {Number} result.minute  - 分钟；当maxUnit < 'minute' 时，此字段永远为0；
+ *   {Number} result.second  - 秒；
+ *   {Number} result.decimal - 不足最小单位的部分，具体含义与 minUnit 参数相关；例如 minUnit = day 时，此字段表示不足1天的部分
+ */
+const groupTimeDuration = (seconds, maxUnit = 'year', minUnit = 'second', decimal = 2) => {
+  // 时间参数（seconds）检查
+  const sec = typeof seconds === 'number' ? seconds : parseFloat(seconds);
+  if (isNaN(sec)) return { year: -1, month: 0, day: 0, hour: 0, minute: 0, second: 0, decimal: 0 };
+
+  // 各时间单位对应的秒数
+  const unitSeconds = { year: 31536000, month: 2592000, day: 86400, hour: 3600, minute: 60, second: 1 };
+
+  // 时间单位参数（minUnit，maxUnit）检查
+  const minSeconds = unitSeconds[minUnit] || unitSeconds.second;
+  const maxSeconds = unitSeconds[maxUnit] || unitSeconds.year;
+  if (maxSeconds < minSeconds) return { year: -1, month: 0, day: 0, hour: 0, minute: 0, second: 0, decimal: 0 };
+
+  // 截取在 minUnit maxUnit 之间的计数单位，并按从大到小排序
+  const allUnitKeys = Object.keys(unitSeconds);
+  const groupUnits = allUnitKeys
+    .filter(unit => unitSeconds[unit] >= minSeconds && unitSeconds[unit] <= maxSeconds) // 过滤超出范围的单位
+    .sort((a, b) => unitSeconds[b] - unitSeconds[a]) // 排序
+    .map(unit => ({ name: unit, seconds: unitSeconds[unit] })); // 转换为 { name, seconds } 的形式，方便后面用
+
+  // 各返回字段初始赋值
+  const result = { decimal: 0 };
+  allUnitKeys.forEach(unit => result[unit] = 0);
+  // 从大到小逐个计算赋值
+  // const periodArr = [];
+  let restSeconds = sec; // 剩余待统计描述
+  groupUnits.forEach((unit) => {
+    const curUnitNum = Math.floor(restSeconds / unit.seconds); // 高于当前计数单位的数值
+    result[unit.name] = curUnitNum; // 例如 { year: 1 }
+    restSeconds %= unit.seconds;
+    if (unit.seconds === minSeconds) result.decimal = round(restSeconds / minSeconds, decimal);
+  });
+  return result;
+};
+
+/**
+ * 将时间段进行聚合计算并格式化，得出方便人阅读的文案，例如：3601秒 -> 1小时0分1秒
+ * @param {Number} seconds 时间段的总秒数
+ * @param {String} maxUnit 最大计数单位：second-秒，minute-分，hour-小时，day-天，month-月，year-年；默认 year
+ *                         单位大小：year > Month > day > hour > month > second
+ * @param {String} minUnit 最小计数单位：second-秒，minute-分，hour-小时，day-天，month-月，year-年；默认 second
+ * @param {Number} decimal 有不足最小单位数值的情况下，保留几位小数；默认 2
+ * @returns {String} 示例见测试用例
+ */
+const formatTimeDuration = (seconds, maxUnit = 'year', minUnit = 'second', decimal = 2) => {
+  const result = groupTimeDuration(seconds, maxUnit, minUnit, decimal);
+  if (result.year === -1) return ''; // seconds 不合法 或 maxUnit < minUnit
+  const unitWording = { year: '年', month: '月', day: '天', hour: '小时', minute: '分钟', second: '秒' };
+  const periodArr = [];
+  ['year', 'month', 'day', 'hour', 'minute', 'second'].forEach((unit) => {
+    if (unit !== minUnit) {
+      if (result[unit] > 0) periodArr.push(`${result[unit]}${unitWording[unit]}`); // 如2小时
+    } else { // 当前unit是最小单位，处理不足最小单位的部分
+      const min = round(result[unit] + result.decimal, decimal);
+      if (min > 0) periodArr.push(`${roundStr(min, 2, true)}${unitWording[unit]}`); // 如1.2，0.2
+      else if (periodArr.length === 0) periodArr.push(`1${unitWording[unit]}内`); // 1 unit内
+    }
+  });
+  return periodArr.join('');
+};
+
 /**
  * @function
  * @description 格式化时间
@@ -15,72 +95,44 @@
  */
 const formatTime = (seconds) => {
   if (typeof seconds !== 'number') return seconds;
-
-  const PER_MINUTE = 60 * 1;
-  const PER_HOUR = 60 * PER_MINUTE;
-  const PRE_DAY = 24 * PER_HOUR;
-  let cost = '';
+  const { day, hour, minute, decimal } = groupTimeDuration(seconds, 'day', 'minute', 2);
   // >24小时的显示  【x天】
-  if (seconds >= PRE_DAY) {
-    cost = `${Math.floor(seconds / PRE_DAY)}天`;
+  if (day > 0) return `${day}天`;
   // <1小时的显示  【x分钟】 ，x取整数上限，最低为1分钟。
-  } else if (seconds < PER_HOUR) {
-    cost = `${Math.ceil(seconds / PER_MINUTE)}分钟`;
+  if (hour === 0) return `${Math.ceil(minute + decimal)}分钟`;
   // <24小时&>1小时的显示  【x小时y分钟】 ，分钟取整数上限
-  } else {
-    cost = `${Math.floor(seconds / PER_HOUR)}小时`;
-    const s = seconds % PER_HOUR;
-    if (s > 0) {
-      cost += `${Math.ceil(s / PER_MINUTE)}分钟`;
-    }
-  }
-
+  let cost = `${hour}小时`;
+  const min = Math.ceil(minute + decimal);
+  if (min > 0) cost += `${min}分钟`;
   return cost;
 };
 
 /**
  * @function
  * @description 将秒数格式化为x天y小时z分钟
- * @param       {Number} oriSeconds 秒数
+ * @param       {Number} seconds 秒数
  * @returns      {String} 格式化后的文案
  */
-const formatTimeWithDetails = (oriSeconds) => {
-  let seconds = oriSeconds;
+const formatTimeWithDetails = (seconds) => {
   // 非Number类型，直接返回，不进行处理
   if (typeof seconds !== 'number') return seconds;
   // 参数为NaN类型，直接抛出异常
   if (isNaN(seconds)) throw new Error(`formatTimeWithDetails方法的参数seconds必须时一个非NaN数字，现在的值为${seconds}`);
 
-  // 定义一些常量
-  // 1分钟包含的秒数
-  const PER_MINUTE = 60 * 1;
-  // 1小时包含的秒数
-  const PER_HOUR = 60 * PER_MINUTE;
-  // 1天包含的秒数
-  const PRE_DAY = 24 * PER_HOUR;
+  const { day, hour, minute, decimal } = groupTimeDuration(seconds, 'day', 'minute', 2);
   let cost = '';
-
-  // 秒数多于1天
-  if (seconds >= PRE_DAY) {
-    cost = `${Math.floor(seconds / PRE_DAY)}天`;
-    seconds %= PRE_DAY;
+  const min = Math.ceil(minute + decimal);
+  if (day > 0) { // 秒数多于1天
+    cost = `${day}天${hour}小时`;
+    // 这里大概率是有bug的，从测试用例里能看出：formatTime(86400) => 1天0小时0分钟
+    // 但为了不改变方法原有表现，先这样吧
+    if (min > 0 || hour === 0) cost += `${min}分钟`;
+  } else if (hour === 0) { // 秒数小于1小时
+    cost = `${min}分钟`;
+  } else { // 秒数介于1天和1分钟之间
+    cost = `${hour}小时`;
+    if (min > 0) cost += `${min}分钟`;
   }
-
-  // 秒数小于1小时
-  if (seconds < PER_HOUR) {
-    if (cost) {
-      cost += '0小时';
-    }
-    cost += `${Math.ceil(seconds / PER_MINUTE)}分钟`;
-  } else {
-    // 秒数介于1天和1分钟之间
-    cost += `${Math.floor(seconds / PER_HOUR)}小时`;
-    const s = seconds % PER_HOUR;
-    if (s > 0) {
-      cost += `${Math.ceil(s / PER_MINUTE)}分钟`;
-    }
-  }
-
   return cost;
 };
 
@@ -157,10 +209,46 @@ const dateToString = (date, withTime = false, withSeconds = false, join = '-') =
   return formatDateTime(date || new Date(), fmt);
 };
 
+/**
+ * 将时间字符串转换为Date对象
+ * @param {String} str  时间字符串，如：2022-03-24 20:02:05
+ *   支持对日期完整但时间部分缺失的情况进行处理，如：
+ *     2022-03-24 20:02 -> Date(1648123320000)
+ *     2022-03-24 20:   -> Date(1648123200000)
+ *     2022-03-24 20    -> Date(1648123200000)
+ *     2022-03-24       -> Date(1648051200000)
+ *   小于10的数字可以省略0：
+ *     2022-3-24 20:2   -> Date(1648123320000)
+ *   支持任意分割符，如：
+ *     2022年03月24日 20时02分 -> Date(1648123320000)
+ *     2022/03/24 20:02:05   -> Date(1648123325000)
+ * @returns {Date|Null} 时间对象；转换失败时返回null
+ */
+const parseDateTime = (str) => {
+  const arr = new RegExp(/(\d{4})[^\d]+(\d{1,2})[^\d]+(\d{1,2})(.*)/, 'g').exec(str); // 分割日期和时间
+  if (!(arr && arr.index > -1)) return null; // 日期不合法，转换失败
+  const timeArr = new RegExp(/[^\d]?(\d{1,2})([^\d]+(\d{1,2})([^\d]+(\d{1,2}))?)?/, 'g').exec(arr[4]); // 分割时间
+  const [, year = 0, month = 0, day = 0] = arr; // 解析日期
+  const [, hour = 0, , minute = 0, , second = 0] = timeArr || []; // 解析时间
+
+  const date = new Date();
+  date.setFullYear(year);
+  date.setMonth(month - 1);
+  date.setDate(day);
+  date.setHours(hour);
+  date.setMinutes(minute);
+  date.setSeconds(second);
+  date.setMilliseconds(0);
+  return date;
+};
+
 export {
+  groupTimeDuration,
+  formatTimeDuration,
   formatDateTime,
   formatTime,
   formatTimeStr,
   formatTimeWithDetails,
   dateToString,
+  parseDateTime,
 };

package/src/timeUtils.test.js

@@ -0,0 +1,129 @@
+import { formatTimeDuration, formatTime, formatTimeWithDetails, parseDateTime } from './timeUtils';
+
+describe('timeUtils', () => {
+  describe.only('formatTimeDuration test cases', () => {
+    test.each([
+      [0.001, undefined, undefined, undefined, '1秒内'],
+      [0.01, 'year', 'second', 2, '0.01秒'],
+      [0.01, 'year', 'minute', 2, '1分钟内'],
+      [0.1, 'year', 'second', 2, '0.1秒'],
+      [0.1, 'year', 'minute', 2, '1分钟内'],
+      [1, 'year', 'second', 2, '1秒'],
+      [1, 'year', 'minute', 2, '0.02分钟'],
+      [1, 'year', 'hour', 0, '1小时内'],
+      [1.1, 'year', 'second', 1, '1.1秒'],
+      [60, 'second', 'second', 2, '60秒'],
+      [60, 'year', 'second', 2, '1分钟'],
+      [60, 'year', 'hour', 2, '0.02小时'],
+      [60, 'year', 'hour', 1, '1小时内'],
+      [60, 'year', 'month', 0, '1月内'],
+      [61, 'year', 'second', 0, '1分钟1秒'],
+      [61, 'year', 'minute', 2, '1.02分钟'],
+      [3600, 'year', 'second', 0, '1小时'],
+      [3600, 'year', 'minute', 0, '1小时'],
+      [3600, 'year', 'hour', 0, '1小时'],
+      [3600, 'second', 'second', 2, '3600秒'],
+      [3600, 'minute', 'second', 2, '60分钟'],
+      [3600, 'year', 'day', 2, '0.04天'],
+      [3600, 'year', 'month', 2, '1月内'],
+      [3601, 'year', 'second', 2, '1小时1秒'],
+      [3601, 'year', 'minute', 2, '1小时0.02分钟'],
+      [3601, 'year', 'hour', 2, '1小时'],
+      [86400, 'year', 'second', 2, '1天'],
+      [86400, 'year', 'minute', 2, '1天'],
+      [86400, 'year', 'hour', 2, '1天'],
+      [86400, 'year', 'day', 2, '1天'],
+      [86400, 'hour', 'second', 2, '24小时'],
+      [86400, 'minute', 'second', 2, '1440分钟'],
+      [86400, 'year', 'month', 2, '0.03月'],
+      [86400, 'year', 'year', 2, '1年内'],
+      [86401, 'year', 'second', 2, '1天1秒'],
+      [86401, 'year', 'minute', 2, '1天0.02分钟'],
+      [86401, 'year', 'minute', 0, '1天'],
+      [86401, 'year', 'hour', 2, '1天'],
+      [31536000, 'year', 'second', 2, '1年'],
+      [31536000, 'month', 'second', 2, '12月5天'],
+      [31626061, 'year', 'second', 2, '1年1天1小时1分钟1秒'],
+    ])('formatTimeDuration(%s, %s, %s, %d) => %s', (seconds, maxUnit, minUnit, decimal, expected) => {
+      expect(formatTimeDuration(seconds, maxUnit, minUnit, decimal)).toBe(expected);
+    });
+  });
+
+  describe('formatTime', () => {
+    test.each([
+      ['invalid', 'invalid'],
+      [172800, '2天'],
+      [172799, '1天'],
+      [86401, '1天'],
+      [86400, '1天'],
+      [86399, '23小时60分钟'],
+      [86341, '23小时60分钟'],
+      [86340, '23小时59分钟'],
+      [7200, '2小时'],
+      [3601, '1小时1分钟'],
+      [3600, '1小时'],
+      [3599, '60分钟'],
+      [3541, '60分钟'],
+      [3540, '59分钟'],
+      [61, '2分钟'],
+      [60, '1分钟'],
+      [59, '1分钟'],
+      [1, '1分钟'],
+    ])('formatTime(%s) => %s', (seconds, result) => expect(formatTime(seconds)).toBe(result));
+  });
+
+  describe('formatTimeWithDetails', () => {
+    test('数据非法', () => expect(formatTimeWithDetails('invalid')).toBe('invalid'));
+    test('NaN', () => expect(() => formatTimeWithDetails(parseInt('invalid', 10))).toThrow());
+
+    test.each([
+      [172800, '2天0小时0分钟'],
+      [172799, '1天23小时60分钟'],
+      [172741, '1天23小时60分钟'],
+      [172740, '1天23小时59分钟'],
+      [90001, '1天1小时1分钟'],
+      [90000, '1天1小时'],
+      [86401, '1天0小时1分钟'],
+      [86400, '1天0小时0分钟'],
+      [86399, '23小时60分钟'],
+      [86341, '23小时60分钟'],
+      [86340, '23小时59分钟'],
+      [7200, '2小时'],
+      [7199, '1小时60分钟'],
+      [7141, '1小时60分钟'],
+      [7140, '1小时59分钟'],
+      [3601, '1小时1分钟'],
+      [3600, '1小时'],
+      [3599, '60分钟'],
+      [3541, '60分钟'],
+      [3540, '59分钟'],
+      [61, '2分钟'],
+      [60, '1分钟'],
+      [59, '1分钟'],
+      [1, '1分钟'],
+    ])('formatTime(%s) => %s', (seconds, result) => expect(formatTimeWithDetails(seconds)).toBe(result));
+  });
+
+  describe('parseDateTime', () => {
+    // 转换失败的情况
+    test('不合法转换', () => {
+      const date = parseDateTime('invalid');
+      expect(date).toBe(null);
+    });
+
+    // 转换成功的情况
+    test.each([
+      ['2022-03-24 20:02:05', 1648123325000],
+      ['2022/03/24 20:02', 1648123320000],
+      ['2022/03/24 20:', 1648123200000],
+      ['2022/03/24 20', 1648123200000],
+      ['2022/03/24', 1648051200000],
+      ['2022/03/24 20:2', 1648123320000],
+      ['2022年03月24日20时02分', 1648123320000],
+    ])('parseDateTime(%s) => Date(%d)', (str, timeStamp) => {
+      const date = parseDateTime(str);
+      expect(date).not.toBe(null);
+      expect(date.getTime()).toBe(timeStamp);
+    });
+  });
+});