@ivujs/i-utils 1.1.16 → 1.1.17

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ivujs/i-utils",
   "moduleName": "iUtils",
-  "version": "1.1.16",
+  "version": "1.1.17",
   "type": "module",
   "description": "前端模块化 JavaScript 工具库",
   "author": "<gao911222@163.com>",
@@ -10,13 +10,6 @@
   "module": "dist/es/index.mjs",
   "unpkg": "dist/lib/index.full.umd.min.js",
   "types": "dist/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "*": [
-        "./dist/index.d.ts"
-      ]
-    }
-  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -29,17 +22,16 @@
       "require": "./dist/resolver/index.cjs"
     },
     "./es": {
-      "types": "./dist/es/index.d.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/es/index.mjs"
     },
     "./cjs": {
       "types": "./dist/index.d.ts",
       "require": "./dist/cjs/index.cjs"
     },
-    "./lib": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/lib/index.full.esm.js",
-      "require": "./dist/lib/index.full.cjs.js"
+    "./umd": {
+      "types": "./dist/es/index.d.ts",
+      "default": "./dist/lib/index.full.umd.min.js"
     }
   },
   "scripts": {

package/dist/cjs/ID-card/index.cjs

@@ -1,87 +0,0 @@
-'use strict';
-
-var index = require('../validate/index.cjs');
-var index$1 = require('../date/index.cjs');
-var idCard = require('../constants/id-card.cjs');
-
-/**
- * 根据身份证号码获取信息
- * @description 能获取到 籍贯，出生日期，年龄，性别
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {Object} 返回身份证信息对象
- */
-function getInfoByIDCard(idCard) {
-    if (index.isNull(idCard))
-        return;
-    return {
-        // 省份
-        province: getProvinceByIDCard(idCard),
-        // 生日
-        birthday: getBirthdayByIDCard(idCard),
-        // 年龄
-        age: getAgeByIDCard(idCard),
-        // 性别
-        sex: getSexByIDCard(idCard),
-    };
-}
-/**
- * 根据身份证号码获得生日
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {String} 返回生日
- */
-function getBirthdayByIDCard(idCard) {
-    if (index.isNull(idCard))
-        return;
-    // 15位身份证
-    if (idCard.length === 15) {
-        return "19" + idCard.substring(6, 8) + "-" + idCard.substring(8, 10) + "-" + idCard.substring(10, 12);
-    }
-    // 18位身份证
-    if (idCard.length === 18) {
-        return idCard.substring(6, 10) + "-" + idCard.substring(10, 12) + "-" + idCard.substring(12, 14);
-    }
-}
-/**
- * 根据身份证号码获得年龄
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {Number} 返回年龄
- */
-function getAgeByIDCard(idCard) {
-    if (index.isNull(idCard))
-        return;
-    let birthday = getBirthdayByIDCard(idCard);
-    return index$1.getAge(index$1.parseDate(birthday));
-}
-/**
- * 根据身份证号码获得性别
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {String} 返回性别
- */
-function getSexByIDCard(idCard$1) {
-    if (index.isNull(idCard$1))
-        return;
-    // 15位身份证
-    if (idCard$1.length === 15) {
-        return Number(idCard$1.substring(14)) % 2 === 0 ? idCard.ID_CARD.SEX.WOMAN : idCard.ID_CARD.SEX.MAN;
-    }
-    // 18位身份证
-    if (idCard$1.length === 18) {
-        return Number(idCard$1.substring(16, 17)) % 2 === 0 ? idCard.ID_CARD.SEX.WOMAN : idCard.ID_CARD.SEX.MAN;
-    }
-}
-/**
- * 根据身份证号码获得省份
- * @param {String} idCard 身份证号码，支持一代15位和二代18位
- * @returns {String} 返回省份
- */
-function getProvinceByIDCard(idCard$1) {
-    if (index.isNull(idCard$1))
-        return;
-    return idCard.ID_CARD.PROVINCE[idCard$1.substring(0, 2)];
-}
-
-exports.getAgeByIDCard = getAgeByIDCard;
-exports.getBirthdayByIDCard = getBirthdayByIDCard;
-exports.getInfoByIDCard = getInfoByIDCard;
-exports.getProvinceByIDCard = getProvinceByIDCard;
-exports.getSexByIDCard = getSexByIDCard;

package/dist/cjs/array/index.cjs

@@ -1,470 +0,0 @@
-'use strict';
-
-var sort = require('../constants/sort.cjs');
-var index = require('../validate/index.cjs');
-
-/* 数组计算 */
-/**
- * 数组最小值
- * @param {Array} array 数组
- * @returns {Number} 返回最小值
- */
-function arrayMin(array) {
-    return Math.min.apply(null, array);
-}
-/**
- * 数组最大值
- * @param {Array} array 数组
- * @returns {Number} 返回最大值
- */
-function arrayMax(array) {
-    return Math.max.apply(null, array);
-}
-/**
- * 数组求和
- * @param {Array} array 数组
- * @returns {Number} 返回和
- */
-function arraySum(array) {
-    return array.reduce(function (pre, cur) {
-        return pre + cur;
-    });
-}
-/**
- * 数组求平均值
- * @param {Array} array 数组
- * @returns {Number} 返回平均数
- */
-function arrayAvg(array) {
-    return arraySum(array) / array.length;
-}
-/* 数组比较 */
-/**
- * 数组中是否包含指定的元素
- * @param {String|Number} value 元素
- * @param {Array} array 查找的数组
- * @returns {Boolean} 返回结果
- */
-function inArray(value, array) {
-    if (index.isNull(value))
-        return false;
-    return array.includes(value);
-}
-/**
- * 比较两个数组是否相等
- * @param {Array} array1 数组1
- * @param {Array} array2 数组2
- * @returns {Boolean} 返回结果
- */
-function arrayEquals(array1, array2) {
-    if (array1 === array2)
-        return true;
-    if (array1.length !== array2.length)
-        return false;
-    return array1.every((v, i) => v === array2[i]);
-}
-/* 数组操作 */
-/**
- * 生成指定长度的数组
- * @param {Number} length 长度，默认 0
- * @returns {Array} 返回数组
- */
-function arrayCreate(length = 0) {
-    return [...Array(length).keys()];
-}
-/**
- * 数组指定位置添加元素
- * @description 如果数组为空，则在0位置添加元素
- * @param {Array} array 数组
- * @param {Number} index 下标位置，默认0
- * @param {*} value 添加的元素
- * @returns {Array} 返回操作后的数组
- */
-function arrayInsert(array = [], index = 0, value = undefined) {
-    if (index < 0)
-        return array;
-    if (array.length === 0) {
-        array.push(value);
-    }
-    else {
-        if (index > array.length - 1) {
-            return array;
-        }
-        array.splice(index, 0, value);
-    }
-    return array;
-}
-/**
- * 数组指定位置前面添加元素
- * @description 如果数组为空，则在0位置添加元素
- * @param {Array} array 数组
- * @param {Number} index 下标位置，默认0
- * @param {*} value 添加的元素
- * @returns {Array} 返回操作后的数组
- */
-function arrayInsertBefore(array = [], index = 0, value = undefined) {
-    if (index < 0)
-        return array;
-    if (array.length === 0) {
-        array.push(value);
-    }
-    else {
-        if (index > array.length - 1) {
-            return array;
-        }
-        array.splice(index, 0, value);
-    }
-    return array;
-}
-/**
- * 数组指定位置后面添加元素
- * @description 如果数组为空，则在0位置添加元素
- * @param {Array} array 数组
- * @param {Number} index 下标位置，默认0
- * @param {*} value 添加的元素
- * @returns {Array} 返回操作后的数组
- */
-function arrayInsertAfter(array = [], index = 0, value = undefined) {
-    if (index < 0)
-        return array;
-    if (array.length === 0) {
-        array.push(value);
-    }
-    else {
-        if (index > array.length - 1) {
-            return array;
-        }
-        array.splice(index, 0, array.splice(index, 1, value)[0]);
-    }
-    return array;
-}
-/**
- * 数组指定位置删除元素
- * @param {Array} array 数组
- * @param {Number} index 下标位置，默认0
- * @returns {Array} 返回操作后的数组
- */
-function arrayRemove(array = [], index = 0) {
-    if (index < 0 || index > array.length - 1)
-        return array;
-    array.splice(index, 1);
-    return array;
-}
-/**
- * 数组指定位置前面删除元素
- * @param {Array} array 数组
- * @param {Number} index 下标位置，默认0
- * @returns {Array} 返回操作后的数组
- */
-function arrayRemoveBefore(array = [], index = 0) {
-    if (index <= 0 || index > array.length - 1)
-        return array;
-    array.splice(index - 1, 1);
-    return array;
-}
-/**
- * 数组指定位置后面删除元素
- * @param {Array} array 数组
- * @param {Number} index 下标位置，默认0
- * @returns {Array} 返回操作后的数组
- */
-function arrayRemoveAfter(array = [], index = 0) {
-    if (index < 0 || index > array.length - 1)
-        return array;
-    array.splice(index + 1, 1);
-    return array;
-}
-/**
- * 数组置顶
- * @param {Array} array 数组
- * @param {Number} index 下标位置，默认0
- * @returns {Array} 返回操作后的数组
- */
-function arrayTop(array = [], index = 0) {
-    if (index < 0 || index > array.length - 1)
-        return array;
-    array.unshift(array.splice(index, 1)[0]);
-    return array;
-}
-/**
- * 数组置尾
- * @param {Array} array 数组
- * @param {Number} index 下标位置，默认0
- * @returns {Array} 返回操作后的数组
- */
-function arrayBottom(array = [], index = 0) {
-    if (index < 0 || index > array.length - 1)
-        return array;
-    array.push(array.splice(index, 1)[0]);
-    return array;
-}
-/**
- * 数组向上移动
- * @param {Array} array 数组
- * @param {Number} index 下标位置，默认0
- * @returns {Array} 返回操作后的数组
- */
-function arrayUp(array = [], index = 0) {
-    if (index < 0 || index > array.length - 1)
-        return array;
-    if (index > 0) {
-        array.splice(index - 1, 0, array.splice(index, 1)[0]);
-    }
-    else {
-        array.push(array.splice(index, 1)[0]);
-    }
-    return array;
-}
-/**
- * 数组向下移动
- * @param {Array} array 数组
- * @param {Number} index 下标位置，默认0
- * @returns {Array} 返回操作后的数组
- */
-function arrayDown(array = [], index = 0) {
-    if (index < 0 || index > array.length - 1)
-        return array;
-    if (index < array.length - 1) {
-        array.splice(index + 1, 0, array.splice(index, 1)[0]);
-    }
-    else {
-        array.unshift(array.splice(index, 1)[0]);
-    }
-    return array;
-}
-/**
- * 数组交换元素
- * @param {Array} array 数组
- * @param {Number} sourceIndex 原索引
- * @param {Number} targetIndex 目标索引
- * @returns {Array} 返回操作后的数组
- */
-function arraySwap(array, sourceIndex, targetIndex) {
-    if (sourceIndex < 0 || targetIndex < 0 || sourceIndex > array.length - 1 || targetIndex > array.length - 1) {
-        return array;
-    }
-    [array[targetIndex], array[sourceIndex]] = [array[sourceIndex], array[targetIndex]];
-    return array;
-}
-/**
- * 数组排序
- * @param {Array} array 数组
- * @param {Number} mode 排序模式，参考常量集合中 数组常量，默认是升序
- * @returns {Array} 返回操作后的数组
- */
-function arraySort(array, mode = sort.SORT.ASC) {
-    return array.sort((a, b) => {
-        switch (mode) {
-            // 升序
-            case sort.SORT.ASC:
-                return a - b;
-            // 降序
-            case sort.SORT.DESC:
-                return b - a;
-            // 随机
-            case sort.SORT.RANDOM:
-                return Math.random() - 0.5;
-            // 默认
-            default:
-                return array;
-        }
-    });
-}
-/**
- * 数组属性混合排序
- * @description 排序默认为asc升序
- * @param {Array} array 数组
- * @param {Array} props 排序的属性
- * @returns {Array} 返回操作后的数组
- */
-function arraySortBy(array, props) {
-    return array.sort((a, b) => {
-        for (let item of props) {
-            // 排序配置
-            let prop = "", order = "asc";
-            if (index.isObject(item)) {
-                prop = item.prop;
-                order = item.order || "asc";
-            }
-            else {
-                prop = item;
-                order = "asc";
-            }
-            // 排序逻辑
-            if (a[prop] < b[prop]) {
-                return order === "asc" ? -1 : 1;
-            }
-            if (a[prop] > b[prop]) {
-                return order === "asc" ? 1 : -1;
-            }
-        }
-        return 0;
-    });
-}
-/**
- * 数组元素去重
- * @param {Array} array 数组
- * @returns {Array} 返回操作后的数组
- */
-function arrayUnique(array) {
-    if (index.isEmpty(array))
-        return [];
-    return Array.from(new Set(array));
-}
-/**
- * 数组打乱元素
- * @description 可以适用于一些抽奖人员列表打乱顺序
- * @param {Array} array 数组
- * @returns {Array} 返回操作后的数组
- */
-function arrayShuffle(array) {
-    for (let i = 1; i < array.length; i++) {
-        const random = Math.floor(Math.random() * (i + 1));
-        [array[random], array[i]] = [array[i], array[random]];
-    }
-    return array;
-}
-/* 数组转换 */
-/**
- * 普通数组转树形结构
- * @description 包含id和pid属性关系的一维数组，转为children的树形结构
- * @param {Array} array 数组
- * @param {Object} setting 配置项
- * @returns {Array} 返回树形节点
- */
-function arrayToTree(array, setting = { key: "id", parentKey: "pid", childrenKey: "children" }) {
-    let key = setting.key, parentKey = setting.parentKey, childrenKey = setting.childrenKey;
-    // 数组或者key是否为空
-    if (!array || array.length === 0 || !key || key === "")
-        return [];
-    // 获得子节点方法
-    const nodeChildren = function (node, childrenKey, newChildren) {
-        if (!node) {
-            return null;
-        }
-        if (typeof newChildren !== "undefined") {
-            node[childrenKey] = newChildren;
-        }
-        return node[childrenKey];
-    };
-    // 声明变量
-    let result = [];
-    let tempMap = {};
-    for (let i = 0; i < array.length; i++) {
-        // 如果源数据数组中有children，则需要删除掉，否则会导致和之前的children合并
-        array[i][childrenKey] && delete array[i][childrenKey];
-        tempMap[array[i][key]] = array[i];
-    }
-    for (let i = 0; i < array.length; i++) {
-        let parent = tempMap[array[i][parentKey]];
-        if (parent && array[i][key] !== array[i][parentKey]) {
-            let children = nodeChildren(parent, childrenKey);
-            if (!children) {
-                children = nodeChildren(parent, childrenKey, []);
-            }
-            children.push(array[i]);
-        }
-        else {
-            result.push(array[i]);
-        }
-    }
-    // 返回结果
-    return result;
-}
-/**
- * 树形结构转普通数组
- * @param {Array} nodes 树形节点
- * @param {Object} setting 配置项
- * @returns {Array} 返回普通数组
- */
-function treeToArray(nodes, setting = { childrenKey: "children" }) {
-    let childrenKey = setting.childrenKey;
-    let result = [];
-    for (let node of nodes) {
-        // 删除掉多余空的children
-        if (node[childrenKey] && !node[childrenKey].length) {
-            delete node[childrenKey];
-        }
-        result.push(node);
-        // 继续执行
-        if (node[childrenKey] && node[childrenKey].length) {
-            let array = treeToArray(node[childrenKey], setting);
-            array && result.push(...array);
-        }
-    }
-    // 返回结果
-    return result;
-}
-/* 数组求并集，交集，差集等 */
-/**
- * 数组求并集
- * @description 数组1 和 数组2 合并一起的元素集合
- * @param {Array} array1 数组1
- * @param {Array} array2 数组2
- * @returns {Array} 返回数组
- */
-function arrayUnion(array1, array2) {
-    return [...new Set(array1.concat(array2))];
-}
-/**
- * 数组求交集
- * @description 数组1 和 数组2 相同的元素集合
- * @param {Array} array1 数组1
- * @param {Array} array2 数组2
- * @returns {Array} 返回数组
- */
-function arrayIntersect(array1, array2) {
-    return [...new Set(array1)].filter((item) => array2.includes(item));
-}
-/**
- * 数组求差集
- * @description 数组1 中不包含 数组2 的元素集合
- * @param {Array} array1 数组1
- * @param {Array} array2 数组2
- * @returns {Array} 返回数组
- */
-function arrayDifference(array1, array2) {
-    return [...new Set(array1)].filter((item) => !array2.includes(item));
-}
-/**
- * 数组求补集
- * @description 数组1 和 数组2 不相同的元素集合
- * @param {Array} array1 数组1
- * @param {Array} array2 数组2
- * @returns {Array} 返回数组
- */
-function arrayComplement(array1, array2) {
-    return [
-        ...[...new Set(array1)].filter((item) => !array2.includes(item)),
-        ...[...new Set(array2)].filter((item) => !array1.includes(item)),
-    ];
-}
-
-exports.arrayAvg = arrayAvg;
-exports.arrayBottom = arrayBottom;
-exports.arrayComplement = arrayComplement;
-exports.arrayCreate = arrayCreate;
-exports.arrayDifference = arrayDifference;
-exports.arrayDown = arrayDown;
-exports.arrayEquals = arrayEquals;
-exports.arrayInsert = arrayInsert;
-exports.arrayInsertAfter = arrayInsertAfter;
-exports.arrayInsertBefore = arrayInsertBefore;
-exports.arrayIntersect = arrayIntersect;
-exports.arrayMax = arrayMax;
-exports.arrayMin = arrayMin;
-exports.arrayRemove = arrayRemove;
-exports.arrayRemoveAfter = arrayRemoveAfter;
-exports.arrayRemoveBefore = arrayRemoveBefore;
-exports.arrayShuffle = arrayShuffle;
-exports.arraySort = arraySort;
-exports.arraySortBy = arraySortBy;
-exports.arraySum = arraySum;
-exports.arraySwap = arraySwap;
-exports.arrayToTree = arrayToTree;
-exports.arrayTop = arrayTop;
-exports.arrayUnion = arrayUnion;
-exports.arrayUnique = arrayUnique;
-exports.arrayUp = arrayUp;
-exports.inArray = inArray;
-exports.treeToArray = treeToArray;