@ivujs/i-utils 1.1.1 → 1.1.2

package/dist/es/function/index.mjs

@@ -1,63 +0,0 @@
-/**
- * 防抖函数
- * @description 事件执行后，在延迟时间内如果再次执行，会清空定时器重新延迟执行，举例：用户在输入框进行输入搜索，最终是会获取到最后一次输入，节约请求资源
- * @param {Function} fn 目标函数
- * @param {Number} delay 延迟时间，单位毫秒，默认 1*1000 毫秒
- * @param {Boolean} immediate 是否立即执行，默认true
- * @returns {Function} 返回function()
- */
-function debounce(fn, delay = 1 * 1000, immediate = true) {
-  let timer;
-  return function () {
-    const _args = arguments;
-    // 先关闭定时器
-    if (timer) clearTimeout(timer);
-    // 立即执行判断
-    if (immediate) {
-      // 如果需要立即执行
-      // 开启新定时器防止短时间内再次触发
-      const canExecute = !timer;
-      timer = setTimeout(function () {
-        timer = null;
-      }, delay);
-      if (canExecute) fn.apply(this, _args);
-    } else {
-      // 如果不需要立即执行
-      // 每次触发开启新定时器即可
-      timer = setTimeout(function () {
-        fn.apply(this, _args);
-      }, delay);
-    }
-  };
-}
-
-/**
- * 节流函数
- * @description 高频触发时，在指定时间间隔内只执行一次，举例：监听页面滚动，不会频繁触发，只会在固定时间内获取一次
- * @param {Function} fn 目标函数
- * @param {Number} interval 时间间隔，单位毫秒，默认1*1000毫秒
- * @returns {Function} 返回function()
- */
-function throttle(fn, interval = 1 * 1000) {
-  let timer;
-  return function () {
-    const _args = arguments;
-    // 有定时器则返回
-    if (timer) return;
-    timer = setTimeout(() => {
-      timer = null;
-      fn.apply(this, _args);
-    }, interval);
-  };
-}
-
-/**
- * 睡眠延迟执行
- * @description 需要配合 async/await 来达到延迟效果
- * @param {Number} delay 延迟时间，单位毫秒，默认1*1000毫秒
- */
-function sleep(delay = 1 * 1000) {
-  return new Promise((resolve) => setTimeout(resolve, delay));
-}
-
-export { debounce, sleep, throttle };

package/dist/es/keycode/index.mjs

@@ -1,139 +0,0 @@
-const keyCodeMap = {
-  // 字符键
-  8: "Backspace",
-  9: "Tab",
-  13: "Enter",
-  16: "Shift",
-  17: "Ctrl",
-  18: "Alt",
-  19: "Pause",
-  20: "Caps Lock",
-  27: "Escape",
-  32: "Space",
-  33: "Page Up",
-  34: "Page Down",
-  35: "End",
-  36: "Home",
-  37: "Left",
-  38: "Up",
-  39: "Right",
-  40: "Down",
-  42: "Print Screen",
-  45: "Insert",
-  46: "Delete",
-  // 数字键
-  48: "0",
-  49: "1",
-  50: "2",
-  51: "3",
-  52: "4",
-  53: "5",
-  54: "6",
-  55: "7",
-  56: "8",
-  57: "9",
-  // 字母键
-  65: "A",
-  66: "B",
-  67: "C",
-  68: "D",
-  69: "E",
-  70: "F",
-  71: "G",
-  72: "H",
-  73: "I",
-  74: "J",
-  75: "K",
-  76: "L",
-  77: "M",
-  78: "N",
-  79: "O",
-  80: "P",
-  81: "Q",
-  82: "R",
-  83: "S",
-  84: "T",
-  85: "U",
-  86: "V",
-  87: "W",
-  88: "X",
-  89: "Y",
-  90: "Z",
-  // window
-  91: "Windows",
-  93: "Right Click",
-  // Numpad
-  96: "Numpad 0",
-  97: "Numpad 1",
-  98: "Numpad 2",
-  99: "Numpad 3",
-  100: "Numpad 4",
-  101: "Numpad 5",
-  102: "Numpad 6",
-  103: "Numpad 7",
-  104: "Numpad 8",
-  105: "Numpad 9",
-  106: "Numpad *",
-  107: "Numpad +",
-  109: "Numpad -",
-  110: "Numpad .",
-  111: "Numpad /",
-  // F功能键
-  112: "F1",
-  113: "F2",
-  114: "F3",
-  115: "F4",
-  116: "F5",
-  117: "F6",
-  118: "F7",
-  119: "F8",
-  120: "F9",
-  121: "F10",
-  122: "F11",
-  123: "F12",
-  // 特殊符号
-  144: "Num Lock",
-  145: "Scroll Lock",
-  182: "My Computer",
-  183: "My Calculator",
-  186: ";",
-  187: "=",
-  188: ",",
-  189: "-",
-  190: ".",
-  191: "/",
-  192: "`",
-  219: "[",
-  220: "\\",
-  221: "]",
-  222: "'",
-};
-
-/**
- * 根据keycode获得键名
- * @param  {Number} keycode 键值
- * @returns {String} 返回键名
- */
-function getKeyName(keycode) {
-  if (keyCodeMap[keycode]) {
-    return keyCodeMap[keycode];
-  } else {
-    console.log("Unknow Key Code: " + keycode);
-    return "";
-  }
-}
-
-/**
- * 根据keyname获得键值
- * @param  {Number} keyname
- * @returns {Number} 返回键值
- */
-function getKeyCode(keyname) {
-  for (let key in keyCodeMap) {
-    if (keyCodeMap[key] === keyname) {
-      return key;
-    }
-  }
-}
-
-export { getKeyCode, getKeyName };

package/dist/es/math/index.mjs

@@ -1,274 +0,0 @@
-import { isNaN } from '../validate/index.mjs';
-import { MATH } from '../constants/math.mjs';
-
-/* 数字计算 */
-/**
- * 两个数字相加
- * @param {String|Number} arg1 第一个数字
- * @param {String|Number} arg2 第二个数字
- * @returns {Number} 返回计算后的数字
- */
-function add(arg1, arg2) {
-  let r1, r2, m;
-  try {
-    r1 = arg1.toString().split(".")[1].length;
-  } catch (e) {
-    r1 = 0;
-  }
-  try {
-    r2 = arg2.toString().split(".")[1].length;
-  } catch (e) {
-    r2 = 0;
-  }
-  m = Math.pow(10, Math.max(r1, r2));
-  return (arg1 * m + arg2 * m) / m;
-}
-
-/**
- * 两个数字相减
- * @param {String|Number} arg1 第一个数字
- * @param {String|Number} arg2 第二个数字
- * @returns {Number} 返回计算后的数字
- */
-function subtract(arg1, arg2) {
-  let r1, r2, m, n;
-  try {
-    r1 = arg1.toString().split(".")[1].length;
-  } catch (e) {
-    r1 = 0;
-  }
-  try {
-    r2 = arg2.toString().split(".")[1].length;
-  } catch (e) {
-    r2 = 0;
-  }
-  m = Math.pow(10, Math.max(r1, r2));
-  n = r1 >= r2 ? r1 : r2;
-  return ((arg1 * m - arg2 * m) / m).toFixed(n);
-}
-
-/**
- * 两个数字相乘
- * @param {String|Number} arg1 第一个数字
- * @param {String|Number} arg2 第二个数字
- * @returns 返回计算后的数字
- */
-function multiply(arg1, arg2) {
-  let m = 0,
-    s1 = arg1.toString(),
-    s2 = arg2.toString();
-  try {
-    m += s1.split(".")[1].length;
-  } catch (e) {}
-  try {
-    m += s2.split(".")[1].length;
-  } catch (e) {}
-  return (Number(s1.replace(".", "")) * Number(s2.replace(".", ""))) / Math.pow(10, m);
-}
-
-/**
- * 两个数字相除
- * @param {String|Number} arg1 第一个数字
- * @param {String|Number} arg2 第二个数字
- * @returns {Number} 返回计算后的数字
- */
-function divide(arg1, arg2) {
-  let t1 = 0,
-    t2 = 0,
-    r1,
-    r2;
-  try {
-    t1 = arg1.toString().split(".")[1].length;
-  } catch (e) {}
-  try {
-    t2 = arg2.toString().split(".")[1].length;
-  } catch (e) {}
-  r1 = Number(arg1.toString().replace(".", ""));
-  r2 = Number(arg2.toString().replace(".", ""));
-  return (r1 / r2) * Math.pow(10, t2 - t1);
-}
-
-/**
- * 两个数字取模
- * @param {String|Number} arg1 第一个数字
- * @param {String|Number} arg2 第二个数字
- * @returns {Number} 返回计算后的数字
- */
-function modulo(arg1, arg2) {
-  let t1 = 0,
-    t2 = 0,
-    d = 0;
-  try {
-    t1 = arg1.toString().split(".")[1].length;
-  } catch (e) {}
-  try {
-    t2 = arg2.toString().split(".")[1].length;
-  } catch (e) {}
-  d = Math.pow(10, Math.max(t1, t2));
-  return (Math.round(Number(arg1) * d) % Math.round(Number(arg2) * d)) / d;
-}
-
-/**
- * 最大公约数
- * @param {String|Number} arg1 第一个数字
- * @param {String|Number} arg2 第二个数字
- * @returns {Number} 返回计算后的数字
- */
-function gcd(arg1, arg2) {
-  return !arg2 ? arg1 : gcd(arg2, arg1 % arg2);
-}
-
-/**
- * 最小公倍数
- * @param {String|Number} arg1 第一个数字
- * @param {String|Number} arg2 第二个数字
- * @returns {Number} 返回计算后的数字
- */
-function scm(arg1, arg2) {
-  return (arg1 * arg2) / gcd(arg1, arg2);
-}
-
-/* 数字精度 */
-/**
- * 强制保留小数位数
- * @description 默认保留两位小数，解决原生的toFixed()会五舍六入的问题
- * @param {String|Number} num 数字
- * @param {Number} decimals 保留小数的位数，默认2位
- * @param {Number} mode 保留小数模式
- * @returns {String} 返回保留后的数字字符串
- */
-function toFixed(num, decimals = 2, mode = MATH.ROUND) {
-  // 四舍五入
-  if (mode === MATH.ROUND) {
-    return _toFixedRound(num, decimals);
-  }
-  // 向下舍出
-  if (mode === MATH.ROUND_FLOOR) {
-    return _toFixedFloor(num, decimals);
-  }
-}
-
-/**
- * 尽可能保留小数位数
- * @param {String|Number} num 数字
- * @param {Number} decimals 保留小数的位数，默认2位
- * @param {Number} mode 保留小数模式
- * @returns {Number} 返回保留后的数字
- */
-function toDecimal(num, decimals = 2, mode = MATH.ROUND) {
-  // 四舍五入
-  if (mode === MATH.ROUND) {
-    return _toDecimalRound(num, decimals);
-  }
-  // 向下舍出
-  if (mode === MATH.ROUND_FLOOR) {
-    return _toDecimalFloor(num, decimals);
-  }
-}
-
-/* 内部函数 */
-/**
- * 四舍五入，强制保留小数位数
- * @description 默认保留两位小数，此方法解决原生的toFixed()会五舍六入的问题
- * @param {String|Number} num 数字
- * @param {Number} decimals 保留小数的位数，默认2位
- * @returns {String} 返回字符串的数字
- */
-function _toFixedRound(num, decimals = 2) {
-  if (isNaN(num)) {
-    return "--";
-  }
-  let s = String(num);
-  if (!decimals) decimals = 0;
-  if (s.indexOf(".") === -1) s += ".";
-  s += new Array(decimals + 1).join("0");
-  if (new RegExp("^(-|\\+)?(\\d+(\\.\\d{0," + (decimals + 1) + "})?)\\d*$").test(s)) {
-    let s = "0" + RegExp.$2,
-      pm = RegExp.$1,
-      a = RegExp.$3.length,
-      b = true;
-    if (a === decimals + 2) {
-      a = s.match(/\d/g);
-      if (parseInt(a[a.length - 1]) > 4) {
-        for (let i = a.length - 2; i >= 0; i--) {
-          a[i] = parseInt(a[i]) + 1;
-          if (a[i] === 10) {
-            a[i] = 0;
-            b = i !== 1;
-          } else break;
-        }
-      }
-      s = a.join("").replace(new RegExp("(\\d+)(\\d{" + decimals + "})\\d$"), "$1.$2");
-    }
-    if (b) s = s.substr(1);
-    return (pm + s).replace(/\.$/, "");
-  }
-  return String(num);
-}
-
-/**
- * 向下舍出，强制保留小数位数
- * @description 默认保留两位小数，此方法相当于强制截取小数位数
- * @param {String|Number} num 数字
- * @param {Number} decimals 保留小数的位数，默认2位
- * @returns {Number} 返回字符串的数字
- */
-function _toFixedFloor(num, decimals = 2) {
-  if (isNaN(num)) {
-    return "--";
-  }
-  // 默认为保留的小数点后两位
-  let dec = decimals;
-  let tempNum = Number(num);
-  let pointIndex = String(tempNum).indexOf(".") + 1; // 获取小数点的位置 + 1
-  let pointCount = pointIndex ? String(tempNum).length - pointIndex : 0; // 获取小数点后的个数(需要保证有小数位)
-  // 源数据为整数或者小数点后面小于decimals位的作补零处理
-  if (pointIndex === 0 || pointCount <= dec) {
-    let tempNumA = tempNum;
-    if (pointIndex === 0) {
-      tempNumA = `${tempNumA}.`;
-      for (let index = 0; index < dec - pointCount; index++) {
-        tempNumA = `${tempNumA}0`;
-      }
-    } else {
-      for (let index = 0; index < dec - pointCount; index++) {
-        tempNumA = `${tempNumA}0`;
-      }
-    }
-    return tempNumA;
-  }
-  let realVal = "";
-  // 截取当前数据到小数点后decimals位
-  realVal = `${String(tempNum).split(".")[0]}.${String(tempNum).split(".")[1].substring(0, dec)}`;
-  return String(realVal);
-}
-
-/**
- * 四舍五入，尽可能保留小数
- * @param {String|Number} num 数字
- * @param {Number} decimals 保留小数的位数，默认2位
- * @returns {Number} 返回保留后的数字
- */
-function _toDecimalRound(num, decimals = 2) {
-  if (isNaN(num)) {
-    return "--";
-  }
-  let n = Math.pow(10, decimals);
-  return Math.round(num * n) / n;
-}
-
-/**
- * 向下舍入，尽可能保留小数
- * @param {String|Number} num 数字
- * @param {Number} decimals 保留小数的位数，默认2位
- * @returns {Number} 返回保留后的数字
- */
-function _toDecimalFloor(num, decimals = 2) {
-  if (isNaN(num)) {
-    return "--";
-  }
-  let n = Math.pow(10, decimals);
-  return Math.floor(num * n) / n;
-}
-
-export { add, divide, gcd, modulo, multiply, scm, subtract, toDecimal, toFixed };

package/dist/es/number/index.mjs

@@ -1,12 +0,0 @@
-/**
- * 转为数字类型
- * @description 解决部分浏览器在转换 '08','09'等是0开头时被默认转8进制问题
- * @param {String,number} value 转换的值
- * @param {Number} radix 进制数，默认10进制
- * @returns {Number} 返回转换后的数字
- */
-function parseInt(value, radix = 10) {
-  return Number.parseInt(value, radix);
-}
-
-export { parseInt };

package/dist/es/object/index.mjs

@@ -1,203 +0,0 @@
-import { isEmpty, isObject, isArray, isDate } from '../validate/index.mjs';
-
-/* 对象转换 */
-/**
- * map转object
- * @param {Map} map 参数
- * @returns {Object} 返回Object
- */
-function mapToObject(map) {
-  let obj = Object.create(null);
-  for (let [k, v] of map) {
-    obj[k] = v;
-  }
-  return obj;
-}
-
-/**
- * map转json字符串
- * @param {Map} map 参数
- * @returns {String} 返回Json字符串
- */
-function mapToJson(map) {
-  return JSON.stringify(mapToObject(map));
-}
-
-/**
- * object转map
- * @param {Object} obj 参数
- * @returns {Map} 返回Map
- */
-function objectToMap(obj) {
-  let map = new Map();
-  for (let k of Object.keys(obj)) {
-    map.set(k, obj[k]);
-  }
-  return map;
-}
-
-/**
- * json字符串转map
- * @param {String} json json字符串
- * @returns {Map} 返回Map
- */
-function jsonToMap(json) {
-  return objectToMap(JSON.parse(json));
-}
-
-/**
- * json对象转json字符串
- * @param {Object} json json对象
- * @returns {String} 返回Json字符串
- */
-function stringifyJson(json) {
-  return JSON.stringify(json);
-}
-
-/**
- * json字符串转json对象
- * @param {String} json json字符串
- * @returns {Object} 返回Json对象
- */
-function parseJson(json) {
-  if (isEmpty(json)) return;
-  return JSON.parse(json);
-}
-
-/* 数据拷贝，对比，合并等操作 */
-/**
- * 浅拷贝数据
- * @param {*} source 拷贝的数据
- * @returns {*} 返回浅拷贝的数据
- */
-function clone(source) {
-  return Object.assign(source);
-}
-
-/**
- * 深拷贝数据
- * @param {*} source 拷贝的数据
- * @returns {*} 返回深拷贝的数据
- */
-function cloneDeep(source) {
-  //  Object
-  if (isObject(source)) {
-    let copy = {};
-    for (let attr in source) {
-      if (source.hasOwnProperty(attr)) copy[attr] = cloneDeep(source[attr]);
-    }
-    return copy;
-  }
-
-  //  Array
-  else if (isArray(source)) {
-    let copy = [];
-    for (let i = 0, len = source.length; i < len; i++) {
-      copy[i] = cloneDeep(source[i]);
-    }
-    return copy;
-  }
-
-  //  Date
-  else if (isDate(source)) {
-    let copy = new Date();
-    copy.setTime(source.getTime());
-    return copy;
-  }
-
-  // Other 原路返回源数据
-  else {
-    return source;
-  }
-}
-
-/**
- * 比较两个对象是否相等
- * @description 方法只能对比简单的对象，不能包含function，另外对象的属性顺序不一致也是相等的
- * @param {Object} obj1 对象1
- * @param {Object} obj2 对象2
- * @returns {Boolean} 返回true和false
- */
-function objectEquals(obj1, obj2) {
-  // 比较值相等
-  if (obj1 === obj2) {
-    return true;
-  }
-  // 比较Date
-  if (obj1 instanceof Date && obj2 instanceof Date) {
-    return obj1.getTime() === obj2.getTime();
-  }
-  // 对象比较引用
-  if (!obj1 || !obj2 || (typeof obj1 !== "object" && typeof obj2 !== "object")) {
-    return obj1 === obj2;
-  }
-  // 比较原型
-  if (obj1.prototype !== obj2.prototype) {
-    return false;
-  }
-  // 比较对象的值
-  const keys = Object.keys(obj1);
-  if (keys.length !== Object.keys(obj2).length) {
-    return false;
-  } else {
-    return keys.every((k) => objectEquals(obj1[k], obj2[k]));
-  }
-}
-
-/**
- * 合并对象
- * @param {Object} target 目标对象
- * @param {Object[]} source 原对象列表
- * @returns {Object} 返回合并后的对象
- */
-function merge(target, ...source) {
-  return Object.assign(target, ...source);
-}
-
-/* 根据字符串属性路径操作目标对象 */
-/**
- * 根据字符串属性路径获取目标对象的值
- * @example
- * let res = {code:200, data:{rows:[], pages:{current:1,pageSize:20}}}
- * this._getTargetValueByPath(res, 'data.pages.pageSize'); // 这里会输出20
- * @param {Object} target 目标对象
- * @param {String} path 字符串属性路径
- * @returns {Object} 返回目标对象
- */
-function getTargetValueByPath(target, path = "data") {
-  const paths = (path || "data").split(".");
-  let data = target;
-  // 属性总个数
-  let lastIndex = paths.length - 1;
-  for (const index in paths) {
-    // 如果路径中没有该属性，则创建一个
-    if (data[paths[index]] === null || data[paths[index]] === undefined) {
-      data[paths[index]] = Number(index) !== lastIndex ? {} : undefined;
-    }
-    // 逐层向下找到对应属性的值
-    data = data[paths[index]];
-  }
-  return data;
-}
-
-/**
- * 根据字符串属性路径设置目标对象的值
- * @example
- * let res = {code:200, data:{rows:[], pages:{current:1,pageSize:20}}}
- * this._setTargetValueByPath(res, 'data.pages.pageSize', 30); // 打印res对象会发现pageSize的值改为了30
- * @param {Object} target 目标对象
- * @param {String} path 字符串属性路径
- * @param {*} value 值
- */
-function setTargetValueByPath(target, path = "data", value) {
-  const paths = (path || "data").split(".");
-  // 变量表达式拼接，最终结果如：target['personInfo']['personName']='xxx';
-  let fxStr = "";
-  for (const name of paths) {
-    fxStr += `['${name}']`;
-  }
-  const fn = new Function("target", `target${fxStr}=${value}`);
-  fn(target);
-}
-
-export { clone, cloneDeep, getTargetValueByPath, jsonToMap, mapToJson, mapToObject, merge, objectEquals, objectToMap, parseJson, setTargetValueByPath, stringifyJson };