@ivujs/i-utils 1.1.14 → 1.1.16

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

@@ -0,0 +1,87 @@
+'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

@@ -0,0 +1,470 @@
+'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;

package/dist/cjs/clipboard/index.cjs

@@ -0,0 +1,128 @@
+'use strict';
+
+var index = require('../file/index.cjs');
+
+/**
+ * 获得剪切板数据
+ * @description 获得的剪切板的数据是会返回多个可用的MIME类型，比如是纯文本就返回一个['text/plain']，是复制的html则会返回两个可用的['text/plain','text/html']，是复制的图片则是['image/png']
+ * @returns {Promise} 返回剪切板的数据，是数组形式，如果是文本则是字符串，否则是blob数据
+ */
+function getClipboard() {
+    return new Promise((resolve, reject) => {
+        if (window.navigator.clipboard) {
+            window.navigator.clipboard.read().then((clipboardItems) => {
+                let list = [];
+                for (let item of clipboardItems) {
+                    for (let type of item.types) {
+                        item.getType(type).then(async (blob) => {
+                            // 文本类型，可以直接输出为字符串
+                            if (blob.type.includes("text")) {
+                                let text = await index.blobToText(blob);
+                                list.push({ type: blob.type, data: text });
+                            }
+                            // 图片和其他文件类型，返回blob对象
+                            else {
+                                list.push({ type: blob.type, data: blob });
+                            }
+                        });
+                    }
+                }
+                resolve(list);
+            });
+        }
+        else {
+            console.warn("not support navigator clipboard!");
+        }
+    });
+}
+/**
+ * 获得剪切板文本
+ * @returns {Promise} 返回剪切板文本
+ */
+function getClipboardText() {
+    return new Promise((resolve, reject) => {
+        if (window.navigator.clipboard) {
+            window.navigator.clipboard
+                .readText()
+                .then((text) => {
+                resolve(text);
+            })
+                .catch((error) => {
+                reject(error);
+            });
+        }
+        else {
+            console.warn("not support navigator clipboard!");
+        }
+    });
+}
+/**
+ * 设置剪切板数据
+ * @description 可以设置文本或者blob类型的数据
+ * @param {String,Blob} data 写入的数据，可以是文本或blob数据
+ * @returns {Promise} 返回结果
+ */
+function setClipboard(data) {
+    return new Promise((resolve, reject) => {
+        // 现代浏览器
+        if (window.navigator.clipboard) {
+            let clipboardItem = null;
+            // 是文本类型
+            if (typeof data === "string") {
+                let blob = new Blob([data], { type: "text/plain" });
+                clipboardItem = new window.ClipboardItem({
+                    ["text/plain"]: blob,
+                });
+            }
+            // 其他文件类型
+            else {
+                clipboardItem = new window.ClipboardItem({ [data.type]: data });
+            }
+            // 写入到剪切板中
+            window.navigator.clipboard.write([clipboardItem]).then((success) => {
+                resolve(true);
+            }, (failed) => {
+                reject(false);
+            });
+        }
+        else {
+            console.warn("not support navigator clipboard!");
+        }
+    });
+}
+/**
+ * 设置剪切板文本
+ * @param {String} text 写入的文本
+ * @returns {Promise} 返回结果
+ */
+function setClipboardText(text) {
+    return new Promise((resolve, reject) => {
+        // 现代浏览器
+        if (window.navigator.clipboard) {
+            window.navigator.clipboard.writeText(text).then((success) => {
+                resolve(true);
+            }, (failed) => {
+                reject(false);
+            });
+        }
+        else {
+            console.warn("not support navigator clipboard!");
+        }
+    });
+}
+/**
+ * 清空剪切板
+ * @returns {Promise} 返回结果
+ */
+function clearClipboard() {
+    return new Promise(async (resolve, reject) => {
+        await setClipboardText("");
+        resolve(true);
+    });
+}
+
+exports.clearClipboard = clearClipboard;
+exports.getClipboard = getClipboard;
+exports.getClipboardText = getClipboardText;
+exports.setClipboard = setClipboard;
+exports.setClipboardText = setClipboardText;