@ivujs/i-utils 1.1.1 → 1.1.2

package/dist/es/url/index.mjs

@@ -1,261 +0,0 @@
-import { REGEXP } from '../constants/regexp.mjs';
-import { isArray } from '../validate/index.mjs';
-import { arrayInsertBefore, arrayInsertAfter } from '../array/index.mjs';
-
-/**
- * 获得协议名
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回协议名
- */
-function getProtocol(url = window.location.href) {
-  let match = url.match(REGEXP.URL);
-  if (match) {
-    return match[1] || "";
-  }
-}
-
-/**
- * 获得主机地址
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回主机地址
- */
-function getHost(url = window.location.href) {
-  let match = url.match(REGEXP.URL);
-  if (match) {
-    return (match[2] || "") + (match[3] ? ":" + match[3] : "");
-  }
-}
-
-/**
- * 获得主机名称
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回主机名称
- */
-function getHostName(url = window.location.href) {
-  let match = url.match(REGEXP.URL);
-  if (match) {
-    return match[2] || "";
-  }
-}
-
-/**
- * 获得端口号
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回端口号
- */
-function getPort(url = window.location.href) {
-  let match = url.match(REGEXP.URL);
-  if (match) {
-    return match[3] || "";
-  }
-}
-
-/**
- * 获得地址路径
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回地址路径
- */
-function getUrlPath(url = window.location.href) {
-  let match = url.match(REGEXP.URL);
-  if (match) {
-    return match[4] || "";
-  }
-}
-
-/**
- * 获得hash字符串
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回hash字符串
- */
-function getUrlHash(url = window.location.href) {
-  let match = url.match(REGEXP.URL);
-  if (match) {
-    return match[6] || "";
-  }
-}
-
-/**
- * 获得查询参数字符串
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回查询参数字符串
- */
-function getSearchString(url = window.location.href) {
-  let match = url.match(REGEXP.URL);
-  console.log(match);
-  if (match) {
-    return match[5] || "";
-  }
-}
-
-/**
- * 查询参数字符串中获得某个参数的值
- * @param {String} name 参数名
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回查询到的值
- */
-function getSearchParam(name, url = window.location.href) {
-  name = name.replace(/[[\]]/g, "\\$&");
-  url = getSearchString(url);
-  let reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
-  let match = url.substring(0).match(reg);
-  if (match) {
-    return decodeURIComponent(match[2]);
-  }
-}
-
-/**
- * 查询参数字符串中设置某个参数的值
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回查询参数字符串
- */
-function setSearchParam(name, value, url = window.location.href) {
-  let params = toSearchParam(url);
-  params[name] = value;
-
-  // 返回替换后的url
-  return url.replace(/(\?.+?)(?=#|$)/, "?" + toSearchString(params));
-}
-
-/**
- * 查询参数字符串中是否包含某个参数
- * @param {String} name 参数名
- * @param {String} url url地址，默认当前url地址
- * @returns {Boolean} 返回结果
- */
-function hasSearchParam(name, url = window.location.href) {
-  let params = toSearchParam(url);
-  return params[name] !== undefined;
-}
-
-/**
- * 查询参数字符串中在最前面追加新参数和值
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回查询参数字符串
- */
-function prependSearchParam(name, value, url = window.location.href) {
-  let searchArr = getSearchString(url).split("&");
-  if (isArray(value)) {
-    let arr = [];
-    for (let i = 0; i < value.length; i++) {
-      arr.push(`${encodeURIComponent(name)}[${i}]=${encodeURIComponent(value[i])}`);
-    }
-    searchArr.unshift(...arr);
-  } else {
-    searchArr.unshift(`${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
-  }
-
-  return url.replace(/(\?.+?)(?=#|$)/, "?" + searchArr.join("&"));
-}
-
-/**
- * 查询参数字符串中在某个参数的前面追加新参数和值
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @param {String} beforeParam 在前面追加参数的名称
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回查询参数字符串
- */
-function prependToSearchParam(name, value, beforeParam, url = window.location.href) {
-  let searchArr = getSearchString(url).split("&");
-  let beforeIndex = searchArr.findIndex((v) => v.includes(beforeParam));
-  let beforeArr = arrayInsertBefore(searchArr, beforeIndex, `${name}=${value}`);
-
-  return url.replace(/(\?.+?)(?=#|$)/, "?" + beforeArr.join("&"));
-}
-
-/**
- * 查询参数字符串中在最后面追加新参数和值
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回查询参数字符串
- */
-function appendSearchParam(name, value, url = window.location.href) {
-  let searchArr = getSearchString(url).split("&");
-  searchArr.push(`${name}=${value}`);
-
-  return url.replace(/(\?.+?)(?=#|$)/, "?" + searchArr.join("&"));
-}
-
-/**
- * 查询参数字符串中在某个参数的后面追加新参数和值
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @param {String} afterName 在后面追加参数的名称
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回查询参数字符串
- */
-function appendToSearchParam(name, value, afterName, url = window.location.href) {
-  let searchArr = getSearchString(url).split("&");
-  let beforeIndex = searchArr.findIndex((v) => v.includes(afterName));
-  let afterArr = arrayInsertAfter(searchArr, beforeIndex, `${name}=${value}`);
-
-  return url.replace(/(\?.+?)(?=#|$)/, "?" + afterArr.join("&"));
-}
-
-/**
- * 查询参数字符串中移除某个参数和值
- * @param {String} name 参数名
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回查询参数字符串
- */
-function removeSearchParam(name, url = window.location.href) {
-  let searchArr = getSearchString(url).split("&");
-  let delIndex = searchArr.findIndex((v) => v.includes(name));
-  if (delIndex > -1) {
-    searchArr.splice(delIndex, 1);
-  }
-
-  return url.replace(/(\?.+?)(?=#|$)/, "?" + searchArr.join("&"));
-}
-
-/**
- * 查询参数字符串转为对象
- * @param {String} url url地址，默认当前url地址
- * @returns {Object} 返回参数对象
- */
-function parseSearchParam(url = window.location.href) {
-  let searchString = getSearchString(url);
-  let searchArr = searchString.split("&");
-  let param = {};
-  for (let i = 0; i < searchArr.length; i++) {
-    let arr = searchArr[i].split("=");
-    param[decodeURIComponent(arr[0])] = decodeURIComponent(arr[1] || "");
-  }
-  return param;
-}
-
-/**
- * 对象转为查询参数字符串
- *  @param {Object} params 参数对象
- *  @param {String} url url地址，如果不为空，则会拼接好查询参数字符串的url地址
- *  @returns {String} 返回查询参数字符串
- */
-function formatSearchString(params, url = undefined) {
-  if (typeof params !== "object") return params;
-
-  let arr = [];
-  for (let key in params) {
-    let value = params[key];
-    if (isArray(value)) {
-      for (let i = 0; i < value.length; ++i) {
-        arr.push(encodeURIComponent(key + "[" + i + "]") + "=" + encodeURIComponent(value[i]));
-      }
-    } else {
-      arr.push(encodeURIComponent(key) + "=" + encodeURIComponent(params[key]));
-    }
-  }
-
-  // 如果url不为空，则会返回拼接好url字符串
-  if (url) {
-    return url.replace(/(\?.+?)(?=#|$)/, "?" + arr.join("&"));
-  } else {
-    return arr.join("&");
-  }
-}
-
-export { appendSearchParam, appendToSearchParam, formatSearchString, getHost, getHostName, getPort, getProtocol, getSearchParam, getSearchString, getUrlHash, getUrlPath, hasSearchParam, parseSearchParam, prependSearchParam, prependToSearchParam, removeSearchParam, setSearchParam };

package/dist/es/validate/index.mjs

@@ -1,451 +0,0 @@
-/**
- * 判断是整数
- * @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 === "Function";
-}
-
-/**
- * 判断类型是异步函数 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 ||
-    value === NaN
-  );
-}
-
-/**
- * 判断非数字
- * @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) {
-  return isNull(value) || !(Object.keys(value) || value).length;
-}
-
-/**
- * 判断值不为空
- * @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;
-}
-
-export { deepCompare, equals, equalsIgnoreCase, isArray, isAsyncFunction, isBigInt, isBlank, isBoolean, isDate, isDecimal, isEmpty, isError, isFalse, isFunction, isInteger, isJson, isMap, isNaN, isNotBlank, isNotEmpty, isNotNaN, isNotNull, isNotUndefined, isNull, isNumber, isObject, isPromise, isRegExp, isSet, isString, isSymbol, isTrue, isUndefined, isWeakMap, isWeakSet };