@ivujs/i-utils 1.1.14 → 1.1.16

package/dist/cjs/validate/index.cjs

@@ -0,0 +1,468 @@
+'use strict';
+
+/**
+ * 判断是整数
+ * @param {*} value 参数
+ * @returns {Boolean} result 返回结果
+ */
+function isInteger(value) {
+    return Number.isInteger(value);
+}
+/**
+ * 判断是小数
+ * @param {*} value 参数
+ * @returns {Boolean} result 返回结果
+ */
+function isDecimal(value) {
+    return /^\d+\.\d+$/.test(value);
+}
+/**
+ * 判断类型是数字 Number
+ * @param {Number} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isNumber(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "Number";
+}
+/**
+ * 判断类型是字符串 String
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isString(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "String";
+}
+/**
+ * 判断类型是数组 Array
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isArray(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "Array";
+}
+/**
+ * 判断类型是对象 Object
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isObject(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "Object";
+}
+/**
+ * 判断类型是布尔 Boolean
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isBoolean(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "Boolean";
+}
+/**
+ * 判断类型是日期 Date
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isDate(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "Date";
+}
+/**
+ * 判断类型是函数 Function
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isFunction(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "Function";
+}
+/**
+ * 判断类型是函数字符串 FunctionString
+ * @description 支持普通函数，异步函数，箭头函数
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isFunctionString(value) {
+    if (value) {
+        try {
+            let fn = new Function(`return ${value}`)();
+            return typeof fn === "function";
+        }
+        catch (e) {
+            // 如果发生错误，比如语法错误，那么这不是一个有效的函数
+            return false;
+        }
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * 判断类型是异步函数 AsyncFunction
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isAsyncFunction(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "AsyncFunction";
+}
+/**
+ * 判断类型是 Symbol
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isSymbol(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "Symbol";
+}
+/**
+ * 判断类型是正则 RegExp
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isRegExp(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "RegExp";
+}
+/**
+ * 判断类型是错误 Error
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isError(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "Error";
+}
+/**
+ * 判断类型是 Promise
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isPromise(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "Promise";
+}
+/**
+ *判断类型是 Map
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isMap(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "Map";
+}
+/**
+ * 判断类型是 WeakMap
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isWeakMap(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "WeakMap";
+}
+/**
+ * 判断类型是 Set
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isSet(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "Set";
+}
+/**
+ * 判断类型是 WeakSet
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isWeakSet(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "WeakSet";
+}
+/**
+ * 判断类型是 BigInt
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isBigInt(value) {
+    return Object.prototype.toString.call(value).slice(8, -1) === "BigInt";
+}
+/**
+ * 判断类型是 Json
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isJson(value) {
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/* 数据值校验 */
+/**
+ * 判断值为真
+ * @param {*} value 校验的参数
+ * @returns {Boolean} 返回结果
+ */
+function isTrue(value) {
+    return !isFalse(value);
+}
+/**
+ * 判断值为假
+ * @param {*} value 校验的参数
+ * @returns {Boolean} 返回结果
+ */
+function isFalse(value) {
+    return (value === undefined ||
+        value === null ||
+        value === "undefined" ||
+        value === "null" ||
+        value === 0 ||
+        value === false ||
+        isNaN(value));
+}
+/**
+ * 判断非数字
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isNaN(value) {
+    // window的isNaN函数是有缺陷的，空数组/数组有一个元素，null，空字符串 都会被认为是数字
+    return window.isNaN(value) || isArray(value) || value == null || value === "";
+}
+/**
+ * 判断是数字
+ * @description 等同于isNumber()
+ * @param {*} value 参数
+ * @returns {Boolean} 返回结果
+ */
+function isNotNaN(value) {
+    return !isNaN(value);
+}
+/**
+ * 判断对象为空
+ * @description 判断值是否为空，如果对象初始化了值则不为空
+ * @param {*} value 校验的参数
+ * @returns {Boolean} 返回结果
+ */
+function isNull(value) {
+    return value === undefined || value === null || value === "";
+}
+/**
+ * 判断对象不为空
+ * @description 判断值是否为空，如果对象初始化了值则不为空
+ * @param {*} value 校验的参数
+ * @returns {Boolean} 返回结果
+ */
+function isNotNull(value) {
+    return !isNull(value);
+}
+/**
+ * 判断值为空
+ * @description 判断是否是有意义不为空的值，如果值是{},[]空的数据则为空
+ * @param {*} value 校验的参数
+ * @returns {Boolean} 返回结果
+ */
+function isEmpty(value) {
+    if (isNull(value))
+        return true;
+    if (typeof value === "string" || Array.isArray(value)) {
+        return value.length === 0;
+    }
+    if (typeof value === "object") {
+        if (value instanceof Map || value instanceof Set) {
+            return value.size === 0;
+        }
+        if (value instanceof Date || value instanceof RegExp || value instanceof Error) {
+            return false;
+        }
+        return Object.keys(value).length === 0;
+    }
+    return false;
+}
+/**
+ * 判断值不为空
+ * @description 判断是否是有意义不为空的值，如果值是{},[]空的数据则为空
+ * @param {*} value 校验的参数
+ * @returns {Boolean} 返回结果
+ */
+function isNotEmpty(value) {
+    return !isEmpty(value);
+}
+/**
+ * 判断值是空白的
+ * @description 同时会校验空值，空对象，以及空白符号
+ * @param {*} value 校验的参数
+ * @returns {Boolean} 返回结果
+ */
+function isBlank(value) {
+    return isEmpty(value) || /^\s*$/.test(value);
+}
+/**
+ * 判断值不是空白的
+ * @description 同时会校验空值，空对象，以及空白符号
+ * @param {*} value 校验的参数
+ * @returns {Boolean} 返回结果
+ */
+function isNotBlank(value) {
+    return !isBlank(value);
+}
+/**
+ * 判断值是undefined
+ * @param {*} value 校验的参数
+ * @returns {Boolean} 返回结果
+ */
+function isUndefined(value) {
+    return value === undefined;
+}
+/**
+ * 判断值不是undefined
+ * @param {*} value 校验的参数
+ * @returns {Boolean} 返回结果
+ */
+function isNotUndefined(value) {
+    return !isUndefined(value);
+}
+/* 数据比较 */
+/**
+ * 判断两个值是否相等
+ * @param {String|Number} value1 参数1
+ * @param {String|Number} value2 参数2
+ * @returns {Boolean} 返回结果
+ */
+function equals(value1, value2) {
+    return Object.is(value1, value2);
+}
+/**
+ * 判断两个值是否相等（忽略大小写）
+ * @param {String|Number} value1 参数1
+ * @param {String|Number} value2 参数2
+ * @returns {Boolean} 返回结果
+ */
+function equalsIgnoreCase(value1, value2) {
+    return Object.is(value1.toLowerCase(), value2.toLowerCase());
+}
+/**
+ * 深度对比数据
+ * @description 可以对比任意数据，对象，数组，日期等也可深度对比，对象不区分先后顺序
+ * @param {*} x 数据1
+ * @param {*} y 数据2
+ * @returns {Boolean} 返回结果
+ */
+function deepCompare(x, y) {
+    let i, l, leftChain, rightChain;
+    function compare2Objects(x, y) {
+        let p;
+        // remember that NaN === NaN returns false
+        // and isNaN(undefined) returns true
+        if (isNaN(x) && isNaN(y) && typeof x === "number" && typeof y === "number") {
+            return true;
+        }
+        // Compare primitives and functions.
+        // Check if both arguments link to the same object.
+        // Especially useful on the step where we compare prototypes
+        if (x === y) {
+            return true;
+        }
+        // Works in case when functions are created in constructor.
+        // Comparing dates is a common scenario. Another built-ins?
+        // We can even handle functions passed across iframes
+        if ((typeof x === "function" && typeof y === "function") ||
+            (x instanceof Date && y instanceof Date) ||
+            (x instanceof RegExp && y instanceof RegExp) ||
+            (x instanceof String && y instanceof String) ||
+            (x instanceof Number && y instanceof Number)) {
+            return x.toString() === y.toString();
+        }
+        // At last checking prototypes as good as we can
+        if (!(x instanceof Object && y instanceof Object)) {
+            return false;
+        }
+        if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) {
+            return false;
+        }
+        if (x.constructor !== y.constructor) {
+            return false;
+        }
+        if (x.prototype !== y.prototype) {
+            return false;
+        }
+        // Check for infinitive linking loops
+        if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) {
+            return false;
+        }
+        // Quick checking of one object being a subset of another.
+        for (p in y) {
+            if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
+                return false;
+            }
+            else if (typeof y[p] !== typeof x[p]) {
+                return false;
+            }
+        }
+        for (p in x) {
+            if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
+                return false;
+            }
+            else if (typeof y[p] !== typeof x[p]) {
+                return false;
+            }
+            switch (typeof x[p]) {
+                case "object":
+                case "function":
+                    leftChain.push(x);
+                    rightChain.push(y);
+                    if (!compare2Objects(x[p], y[p])) {
+                        return false;
+                    }
+                    leftChain.pop();
+                    rightChain.pop();
+                    break;
+                default:
+                    if (x[p] !== y[p]) {
+                        return false;
+                    }
+                    break;
+            }
+        }
+        return true;
+    }
+    if (arguments.length < 1) {
+        return true; // Die silently? Don't know how to handle such case, please help...
+        // throw "Need two or more arguments to compare";
+    }
+    for (i = 1, l = arguments.length; i < l; i++) {
+        leftChain = [];
+        rightChain = [];
+        if (!compare2Objects(arguments[0], arguments[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+exports.deepCompare = deepCompare;
+exports.equals = equals;
+exports.equalsIgnoreCase = equalsIgnoreCase;
+exports.isArray = isArray;
+exports.isAsyncFunction = isAsyncFunction;
+exports.isBigInt = isBigInt;
+exports.isBlank = isBlank;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isDecimal = isDecimal;
+exports.isEmpty = isEmpty;
+exports.isError = isError;
+exports.isFalse = isFalse;
+exports.isFunction = isFunction;
+exports.isFunctionString = isFunctionString;
+exports.isInteger = isInteger;
+exports.isJson = isJson;
+exports.isMap = isMap;
+exports.isNaN = isNaN;
+exports.isNotBlank = isNotBlank;
+exports.isNotEmpty = isNotEmpty;
+exports.isNotNaN = isNotNaN;
+exports.isNotNull = isNotNull;
+exports.isNotUndefined = isNotUndefined;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isSet = isSet;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isTrue = isTrue;
+exports.isUndefined = isUndefined;
+exports.isWeakMap = isWeakMap;
+exports.isWeakSet = isWeakSet;

package/dist/cjs/weapp/index.cjs

@@ -0,0 +1,142 @@
+'use strict';
+
+/**
+ * 设置缓存
+ * @param {String} key key值
+ * @param {*} data data数据
+ */
+function setStorageSync(key, data) {
+    wx.setStorageSync(key, data);
+}
+/**
+ * 获得缓存数据
+ * @param {String} key key值
+ * @returns {*} 返回获取的值
+ */
+function getStorageSync(key) {
+    return wx.getStorageSync(key);
+}
+/**
+ * 获得缓存信息
+ * @returns {Object} 返回缓存信息
+ */
+function getStorageInfoSync() {
+    return wx.getStorageInfoSync();
+}
+/**
+ * 删除缓存数据
+ * @param {String} key key值
+ */
+function removeStorageSync(key) {
+    wx.removeStorageSync(key);
+}
+/**
+ * 清空所有缓存数据
+ */
+function clearStorageSync() {
+    wx.clearStorageSync();
+}
+/* 缓存处理（异步） */
+/**
+ * 设置缓存
+ * @param {String} key key值
+ * @param {*} data data数据
+ * @param {Boolean} encrypt 是否开启加密存储
+ * @returns {Promise} 返回Promise
+ */
+function setStorage({ key, data, encrypt = false }) {
+    return new Promise((resolve, reject) => {
+        wx.setStorage({
+            key,
+            data,
+            encrypt,
+            success(res) {
+                resolve(res);
+            },
+            fail(err) {
+                reject(err);
+            },
+        });
+    });
+}
+/**
+ * 获得缓存数据
+ * @param {String} key key值
+ * @param {Boolean} encrypt 是否开启加密存储
+ * @returns {Promise} 返回Promise
+ */
+function getStorage({ key, encrypt = false }) {
+    return new Promise((resolve, reject) => {
+        wx.getStorage({
+            key,
+            encrypt,
+            success(res) {
+                resolve(res);
+            },
+            fail(err) {
+                reject(err);
+            },
+        });
+    });
+}
+/**
+ * 获得缓存信息
+ * @returns {Object} 返回Promise
+ */
+function getStorageInfo() {
+    return new Promise((resolve, reject) => {
+        wx.getStorageInfo({
+            success(res) {
+                resolve(res);
+            },
+            fail(err) {
+                reject(err);
+            },
+        });
+    });
+}
+/**
+ * 删除缓存数据
+ * @param {String} key key值
+ * @returns {Promise} 返回Promise
+ */
+function removeStorage({ key }) {
+    return new Promise((resolve, reject) => {
+        wx.removeStorage({
+            key,
+            success(res) {
+                resolve(res);
+            },
+            fail(err) {
+                reject(err);
+            },
+        });
+    });
+}
+/**
+ * 清空所有缓存数据
+ * @returns {Promise} 返回Promise
+ */
+function clearStorage() {
+    return new Promise((resolve, reject) => {
+        wx.clearStorage({
+            success(res) {
+                resolve(res);
+            },
+            fail(err) {
+                reject(err);
+            },
+        });
+    });
+}
+
+exports.clearStorage = clearStorage;
+exports.clearStorageSync = clearStorageSync;
+exports.getStorage = getStorage;
+exports.getStorageInfo = getStorageInfo;
+exports.getStorageInfoSync = getStorageInfoSync;
+exports.getStorageSync = getStorageSync;
+exports.removeStorage = removeStorage;
+exports.removeStorageSync = removeStorageSync;
+exports.setStorage = setStorage;
+exports.setStorageSync = setStorageSync;

package/dist/es/ID-card/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 根据身份证号码获取信息
+ * @description 能获取到 籍贯，出生日期，年龄，性别
+ * @param {String} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {Object} 返回身份证信息对象
+ */
+export function getInfoByIDCard(idCard: string): Object;
+/**
+ * 根据身份证号码获得生日
+ * @param {String} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {String} 返回生日
+ */
+export function getBirthdayByIDCard(idCard: string): string;
+/**
+ * 根据身份证号码获得年龄
+ * @param {String} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {Number} 返回年龄
+ */
+export function getAgeByIDCard(idCard: string): number;
+/**
+ * 根据身份证号码获得性别
+ * @param {String} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {String} 返回性别
+ */
+export function getSexByIDCard(idCard: string): string;
+/**
+ * 根据身份证号码获得省份
+ * @param {String} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {String} 返回省份
+ */
+export function getProvinceByIDCard(idCard: string): string;

package/dist/es/ID-card/index.mjs

@@ -0,0 +1,81 @@
+import { isNull } from '../validate/index.mjs';
+import { getAge, parseDate } from '../date/index.mjs';
+import { ID_CARD } from '../constants/id-card.mjs';
+
+/**
+ * 根据身份证号码获取信息
+ * @description 能获取到 籍贯，出生日期，年龄，性别
+ * @param {String} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {Object} 返回身份证信息对象
+ */
+function getInfoByIDCard(idCard) {
+    if (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 (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 (isNull(idCard))
+        return;
+    let birthday = getBirthdayByIDCard(idCard);
+    return getAge(parseDate(birthday));
+}
+/**
+ * 根据身份证号码获得性别
+ * @param {String} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {String} 返回性别
+ */
+function getSexByIDCard(idCard) {
+    if (isNull(idCard))
+        return;
+    // 15位身份证
+    if (idCard.length === 15) {
+        return Number(idCard.substring(14)) % 2 === 0 ? ID_CARD.SEX.WOMAN : ID_CARD.SEX.MAN;
+    }
+    // 18位身份证
+    if (idCard.length === 18) {
+        return Number(idCard.substring(16, 17)) % 2 === 0 ? ID_CARD.SEX.WOMAN : ID_CARD.SEX.MAN;
+    }
+}
+/**
+ * 根据身份证号码获得省份
+ * @param {String} idCard 身份证号码，支持一代15位和二代18位
+ * @returns {String} 返回省份
+ */
+function getProvinceByIDCard(idCard) {
+    if (isNull(idCard))
+        return;
+    return ID_CARD.PROVINCE[idCard.substring(0, 2)];
+}
+
+export { getAgeByIDCard, getBirthdayByIDCard, getInfoByIDCard, getProvinceByIDCard, getSexByIDCard };