@logwire/logwire-wms-pda-ui 1.1.15 → 1.1.16

package/src/utils/DateTime.js

@@ -1,219 +1,219 @@
-/*
-* 时间处理
-* @author 张文
-* @date  2022-01-26
-* */
-
-import {Language} from "./Language";
-
-// 内部使用函数，截取指定时间的值
-function timeTextSplit(str, type){
-  // 如果没有传入类型或者当前值不包含传入类型则返回传入值
-  if (!type || !str.includes(type)) return str
-
-  return str.split(type)[0] + type
-}
-
-export const DateTime = {
-
-  /**
-   * 时间格式化
-   * @author 张文
-   * @param date 需要格式化的时间（字符串、时间戳或时间对象）
-   * @param format 格式化表达式
-   */
-  format(date, format = 'yyyy-MM-dd') {
-    if (!date) return '-'
-    const value = date instanceof Date ? date : new Date(date)
-    let o = {
-      'M+': value.getMonth() + 1,
-      'd+': value.getDate(),
-      'h+': value.getHours(),
-      'm+': value.getMinutes(),
-      's+': value.getSeconds(),
-      'q+': Math.floor((value.getMonth() + 3) / 3),
-      'S': value.getMilliseconds()
-    }
-    if (/(y+)/.test(format)) {
-      format = format.replace(RegExp.$1, (value.getFullYear() + '').substr(4 - RegExp.$1.length))
-    }
-    for (let k in o) {
-      if (Object.prototype.hasOwnProperty.call(o, k) && new RegExp('(' + k + ')').test(format)) {
-        format = format.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k].toString() : (('00' + o[k]).substr((o[k].toString()).length)))
-      }
-    }
-    return format
-  },
-
-
-  /**
-   * 计算两个时间的差值
-   * @author 张文
-   * @param  l 起始时间（字符串、时间戳或时间对象）
-   * @param  n 结束时间（字符串、时间戳或时间对象）
-   * @param {String} type 返回的时间类型默认秒钟，可选值：s-秒，m-分钟，h-小时, d-天
-   * @return {Object} { time:返回相减后的值，不足1的忽略不计，ago: l < n 起始时间是否大于结束时间 }
-   * */
-  judgeDate(l, n = new Date(), type = 's') {
-    const a = new Date(this.format(l, 'yyyy-MM-dd hh:mm:ss')).getTime()
-    const b = new Date(this.format(n, 'yyyy-MM-dd hh:mm:ss')).getTime()
-    let time
-    switch (type) {
-      case 's':
-        time = 1000
-        break;
-      case 'm':
-        time = 1000 * 60
-        break;
-      case 'h':
-        time = 1000 * 60 * 60
-        break;
-      case 'd':
-        time = 1000 * 60 * 60 * 24
-        break;
-      default:
-        time = 1000
-        break;
-    }
-
-    const abs = a - b
-
-    return {
-      time: Math.floor(Math.abs(abs) / time),
-      ago: abs < 0
-    }
-  },
-
-
-  /**
-   * 两个时间差转换为中文，可自定义显示到最大时间单位
-   * @author 张文
-   * @param {Object} {l-起始时间, n-结束时间,默认当前时间, s-当前秒数(存在值时忽略 l，n), type-最大显示单位（可选）, agoText-需要在文本后显示的文字（可选）,minType-文本翻译的最小单位}
-   * @param {String} type 参数解释： 最大显示单位 y-年（默认）；m-月，d-日，h-小时，min-分钟，s-秒
-   * @param {String} minType 参数解释： 文本的最小单位 y-年；m-月，d-日，h-小时，min-分钟，s-秒（默认）
-   * @param {String|Boolean} agoText 参数解释： 为空时值为 s > 0 || l-n > 0 ? '后' : '前'，若无需显示任何描述文字传入：false
-   * @return {Object} {y-年, m-月, d-日, h-时, min-分, s-秒, text:当前时间的中文翻译，xx小时xx分xx秒, success-是否处理成功}
-   * */
-  timeToStr({l, n = new Date(), s = 0, type='y', agoText=false, minType='s'}) {
-    const obj = {
-      y: 0,
-      m: 0,
-      d: 0,
-      h: 0,
-      min: 0,
-      s: 0,
-      success:true
-    }
-
-    let time, ago
-
-
-    try {
-
-      // 判断是否传入了需要计算的秒数
-      if (!s) throw Error
-
-      let nTime = Number(s)
-      if (isNaN(nTime) || nTime === 0) {
-        throw Error
-      }
-
-      ago = nTime > 0
-      time = Math.abs(nTime)
-    }catch {
-
-      if (!l || !n){
-        obj.success = false
-        return {
-          ...obj,
-          text:''
-        }
-      }
-
-      let oTime = this.judgeDate(l, n)
-      time = oTime.time
-      ago = oTime.ago
-    }
-
-    const language = {
-      s : Language.get('wms_project.pda.common.sec','秒'),
-      min : Language.get('wms_project.pda.common.min','分钟'),
-      h : Language.get('wms_project.pda.common.hour','小时'),
-      d : Language.get('wms_project.pda.common.day','天'),
-      m : Language.get('wms_project.pda.common.month','月'),
-      y : Language.get('wms_project.pda.common.year','年'),
-    }
-
-    let text
-    if (agoText === false) {
-      text = ''
-    } else if (agoText) {
-      text = agoText
-    } else {
-      text = ago ? Language.get('wms_project.pda.common.ago','前') : Language.get('wms_project.pda.common.old','后')
-    }
-
-
-    const maxMin = Math.floor(time / 60)
-    if (type === 's' || !maxMin) {
-      obj.s = time
-      return {
-        ...obj,
-        text: timeTextSplit(`${obj.s}${language.s}${text}`, language[minType])
-      }
-    }
-
-
-    obj.s = time % 60
-    text = `${obj.s}${language.s}${text}`
-    const maxH = Math.floor(maxMin / 60)
-    if (type === 'min' || !maxH) {
-      obj.min = maxMin
-      return {
-        ...obj,
-        text: timeTextSplit(`${obj.min}${language.min}${text}`, language[minType])
-      }
-    }
-
-    obj.min = maxMin % 60
-    text = `${obj.min}${language.min}${text}`
-    const maxD = Math.floor(maxH / 24)
-    if (type === 'h' || !maxD) {
-      obj.h = maxH
-      return {
-        ...obj,
-        text: timeTextSplit(`${obj.h}${language.h}${text}`, language[minType])
-      }
-    }
-
-    obj.h = maxH % 24
-    text = `${obj.h}${language.h}${text}`
-    const maxM = Math.floor(maxD / 30)
-    if (type === 'd' || !maxM) {
-      obj.d = maxD
-      return {
-        ...obj,
-        text: timeTextSplit(`${obj.d}${language.d}${text}`, language[minType])
-      }
-    }
-
-    obj.d = maxD % 30
-    text = `${obj.d}${language.d}${text}`
-    if (type === 'm' || !obj.y) {
-      obj.m = maxM
-      return {
-        ...obj,
-        text: timeTextSplit(`${obj.m}${language.m}${text}`, language[minType])
-      }
-    }
-
-    obj.m = maxM % 12
-    text = `${obj.m}${language.m}${text}`
-    obj.y = Math.floor(maxM / 12)
-    return {
-      ...obj,
-      text: timeTextSplit(`${obj.y}${language.y}${text}`, language[minType])
-    }
-
-  }
-}
+/*
+* 时间处理
+* @author 张文
+* @date  2022-01-26
+* */
+
+import {Language} from "./Language";
+
+// 内部使用函数，截取指定时间的值
+function timeTextSplit(str, type){
+  // 如果没有传入类型或者当前值不包含传入类型则返回传入值
+  if (!type || !str.includes(type)) return str
+
+  return str.split(type)[0] + type
+}
+
+export const DateTime = {
+
+  /**
+   * 时间格式化
+   * @author 张文
+   * @param date 需要格式化的时间（字符串、时间戳或时间对象）
+   * @param format 格式化表达式
+   */
+  format(date, format = 'yyyy-MM-dd') {
+    if (!date) return '-'
+    const value = date instanceof Date ? date : new Date(date)
+    let o = {
+      'M+': value.getMonth() + 1,
+      'd+': value.getDate(),
+      'h+': value.getHours(),
+      'm+': value.getMinutes(),
+      's+': value.getSeconds(),
+      'q+': Math.floor((value.getMonth() + 3) / 3),
+      'S': value.getMilliseconds()
+    }
+    if (/(y+)/.test(format)) {
+      format = format.replace(RegExp.$1, (value.getFullYear() + '').substr(4 - RegExp.$1.length))
+    }
+    for (let k in o) {
+      if (Object.prototype.hasOwnProperty.call(o, k) && new RegExp('(' + k + ')').test(format)) {
+        format = format.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k].toString() : (('00' + o[k]).substr((o[k].toString()).length)))
+      }
+    }
+    return format
+  },
+
+
+  /**
+   * 计算两个时间的差值
+   * @author 张文
+   * @param  l 起始时间（字符串、时间戳或时间对象）
+   * @param  n 结束时间（字符串、时间戳或时间对象）
+   * @param {String} type 返回的时间类型默认秒钟，可选值：s-秒，m-分钟，h-小时, d-天
+   * @return {Object} { time:返回相减后的值，不足1的忽略不计，ago: l < n 起始时间是否大于结束时间 }
+   * */
+  judgeDate(l, n = new Date(), type = 's') {
+    const a = new Date(this.format(l, 'yyyy-MM-dd hh:mm:ss')).getTime()
+    const b = new Date(this.format(n, 'yyyy-MM-dd hh:mm:ss')).getTime()
+    let time
+    switch (type) {
+      case 's':
+        time = 1000
+        break;
+      case 'm':
+        time = 1000 * 60
+        break;
+      case 'h':
+        time = 1000 * 60 * 60
+        break;
+      case 'd':
+        time = 1000 * 60 * 60 * 24
+        break;
+      default:
+        time = 1000
+        break;
+    }
+
+    const abs = a - b
+
+    return {
+      time: Math.floor(Math.abs(abs) / time),
+      ago: abs < 0
+    }
+  },
+
+
+  /**
+   * 两个时间差转换为中文，可自定义显示到最大时间单位
+   * @author 张文
+   * @param {Object} {l-起始时间, n-结束时间,默认当前时间, s-当前秒数(存在值时忽略 l，n), type-最大显示单位（可选）, agoText-需要在文本后显示的文字（可选）,minType-文本翻译的最小单位}
+   * @param {String} type 参数解释： 最大显示单位 y-年（默认）；m-月，d-日，h-小时，min-分钟，s-秒
+   * @param {String} minType 参数解释： 文本的最小单位 y-年；m-月，d-日，h-小时，min-分钟，s-秒（默认）
+   * @param {String|Boolean} agoText 参数解释： 为空时值为 s > 0 || l-n > 0 ? '后' : '前'，若无需显示任何描述文字传入：false
+   * @return {Object} {y-年, m-月, d-日, h-时, min-分, s-秒, text:当前时间的中文翻译，xx小时xx分xx秒, success-是否处理成功}
+   * */
+  timeToStr({l, n = new Date(), s = 0, type='y', agoText=false, minType='s'}) {
+    const obj = {
+      y: 0,
+      m: 0,
+      d: 0,
+      h: 0,
+      min: 0,
+      s: 0,
+      success:true
+    }
+
+    let time, ago
+
+
+    try {
+
+      // 判断是否传入了需要计算的秒数
+      if (!s) throw Error
+
+      let nTime = Number(s)
+      if (isNaN(nTime) || nTime === 0) {
+        throw Error
+      }
+
+      ago = nTime > 0
+      time = Math.abs(nTime)
+    }catch {
+
+      if (!l || !n){
+        obj.success = false
+        return {
+          ...obj,
+          text:''
+        }
+      }
+
+      let oTime = this.judgeDate(l, n)
+      time = oTime.time
+      ago = oTime.ago
+    }
+
+    const language = {
+      s : Language.get('wms_project.pda.common.sec','秒'),
+      min : Language.get('wms_project.pda.common.min','分钟'),
+      h : Language.get('wms_project.pda.common.hour','小时'),
+      d : Language.get('wms_project.pda.common.day','天'),
+      m : Language.get('wms_project.pda.common.month','月'),
+      y : Language.get('wms_project.pda.common.year','年'),
+    }
+
+    let text
+    if (agoText === false) {
+      text = ''
+    } else if (agoText) {
+      text = agoText
+    } else {
+      text = ago ? Language.get('wms_project.pda.common.ago','前') : Language.get('wms_project.pda.common.old','后')
+    }
+
+
+    const maxMin = Math.floor(time / 60)
+    if (type === 's' || !maxMin) {
+      obj.s = time
+      return {
+        ...obj,
+        text: timeTextSplit(`${obj.s}${language.s}${text}`, language[minType])
+      }
+    }
+
+
+    obj.s = time % 60
+    text = `${obj.s}${language.s}${text}`
+    const maxH = Math.floor(maxMin / 60)
+    if (type === 'min' || !maxH) {
+      obj.min = maxMin
+      return {
+        ...obj,
+        text: timeTextSplit(`${obj.min}${language.min}${text}`, language[minType])
+      }
+    }
+
+    obj.min = maxMin % 60
+    text = `${obj.min}${language.min}${text}`
+    const maxD = Math.floor(maxH / 24)
+    if (type === 'h' || !maxD) {
+      obj.h = maxH
+      return {
+        ...obj,
+        text: timeTextSplit(`${obj.h}${language.h}${text}`, language[minType])
+      }
+    }
+
+    obj.h = maxH % 24
+    text = `${obj.h}${language.h}${text}`
+    const maxM = Math.floor(maxD / 30)
+    if (type === 'd' || !maxM) {
+      obj.d = maxD
+      return {
+        ...obj,
+        text: timeTextSplit(`${obj.d}${language.d}${text}`, language[minType])
+      }
+    }
+
+    obj.d = maxD % 30
+    text = `${obj.d}${language.d}${text}`
+    if (type === 'm' || !obj.y) {
+      obj.m = maxM
+      return {
+        ...obj,
+        text: timeTextSplit(`${obj.m}${language.m}${text}`, language[minType])
+      }
+    }
+
+    obj.m = maxM % 12
+    text = `${obj.m}${language.m}${text}`
+    obj.y = Math.floor(maxM / 12)
+    return {
+      ...obj,
+      text: timeTextSplit(`${obj.y}${language.y}${text}`, language[minType])
+    }
+
+  }
+}

package/src/utils/DeepCopy.js

@@ -1,61 +1,61 @@
-/*
-* 深拷贝
-* @author: 张文
-* @date  2022-02-16
-* */
-import {cloneDeep} from "lodash/lang";
-
-
-/**
- * 深拷贝
- * @author 张文
- * @param {Object} data 需要拷贝的原始数据
- * @return {*} 返回拷贝后的数据
- *
- * */
-export function DeepCopy(data) {
-
-  // 用于判断当前数据是否为DOM对象，没有深拷贝，可能会存在变量改变的风险
-  /*if (data instanceof Element) {
-    return data
-  }*/
-
-  // 文档：https://www.lodashjs.com/docs/lodash.cloneDeep
-  return cloneDeep(data)
-
-
-  /*if (useLodash) {
-    return cloneDeep(data)
-  }
-
-  // 非对象直接返回
-  if (typeof data !== 'object') {
-    return data
-  }
-
-  // 用于判断当前数据是否为DOM对象
-  if (data instanceof Element) {
-    return data
-  }
-
-  // 判断复制的目标是数组还是对象
-  const copy = Array.isArray(data) ? [] : {};
-
-  for (let keys in data) {
-
-    // 不读取对象的私有属性
-    if (/^_/.test(keys)) break
-
-    // 如果值是对象或者数组，就递归一下
-    if (data[keys] && typeof data[keys] === 'object') {
-
-      copy[keys] = lwDeepCopy(data[keys]);
-
-    } else {
-
-      // 如果不是，就直接赋值
-      copy[keys] = data[keys];
-    }
-  }
-  return copy;*/
-}
+/*
+* 深拷贝
+* @author: 张文
+* @date  2022-02-16
+* */
+import {cloneDeep} from "lodash/lang";
+
+
+/**
+ * 深拷贝
+ * @author 张文
+ * @param {Object} data 需要拷贝的原始数据
+ * @return {*} 返回拷贝后的数据
+ *
+ * */
+export function DeepCopy(data) {
+
+  // 用于判断当前数据是否为DOM对象，没有深拷贝，可能会存在变量改变的风险
+  /*if (data instanceof Element) {
+    return data
+  }*/
+
+  // 文档：https://www.lodashjs.com/docs/lodash.cloneDeep
+  return cloneDeep(data)
+
+
+  /*if (useLodash) {
+    return cloneDeep(data)
+  }
+
+  // 非对象直接返回
+  if (typeof data !== 'object') {
+    return data
+  }
+
+  // 用于判断当前数据是否为DOM对象
+  if (data instanceof Element) {
+    return data
+  }
+
+  // 判断复制的目标是数组还是对象
+  const copy = Array.isArray(data) ? [] : {};
+
+  for (let keys in data) {
+
+    // 不读取对象的私有属性
+    if (/^_/.test(keys)) break
+
+    // 如果值是对象或者数组，就递归一下
+    if (data[keys] && typeof data[keys] === 'object') {
+
+      copy[keys] = lwDeepCopy(data[keys]);
+
+    } else {
+
+      // 如果不是，就直接赋值
+      copy[keys] = data[keys];
+    }
+  }
+  return copy;*/
+}