@heyform-inc/utils 1.0.0

package/dist/index.mjs

@@ -0,0 +1,704 @@
+export * from 'deep-object-diff';
+import validatorIsUUID from 'validator/lib/isUUID';
+import _clone from 'clone';
+import dayjs from 'dayjs';
+import * as m from 'mime-types';
+import { customAlphabet } from 'nanoid';
+import * as objectPath from 'object-path';
+import slug from 'slugify';
+export { v4 as uuidv4, v5 as uuidv5 } from 'uuid';
+
+// src/index.ts
+
+// src/type.ts
+var toString = Object.prototype.toString;
+function type(obj) {
+  if (obj === null) {
+    return "null";
+  }
+  let type2 = typeof obj;
+  if (type2 !== "object") {
+    return type2;
+  }
+  type2 = toString.call(obj).slice(8, -1);
+  const typeLower = type2.toLowerCase();
+  if (typeLower !== "object") {
+    if (typeLower === "number" || typeLower === "boolean" || typeLower === "string") {
+      return type2;
+    }
+    return typeLower;
+  }
+  return typeLower;
+}
+var whiteSpaceRegx = /^[\s\f\n\r\t\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000\ufeff\x09\x0a\x0b\x0c\x0d\x20\xa0]+$/;
+var numericRegx = /^[+-]?([0-9]*[.])?[0-9]+$/;
+var isUUID = validatorIsUUID;
+function isBoolean(arg) {
+  return type(arg) === "boolean";
+}
+function isString(arg) {
+  return type(arg) === "string";
+}
+function isNumber(arg) {
+  return type(arg) === "number";
+}
+function isNumeric(arg) {
+  return numericRegx.test(String(arg));
+}
+var isArray = Array.isArray;
+function isValidArray(arg) {
+  return isArray(arg) && arg.length > 0;
+}
+function isNan(arg) {
+  return isNumber(arg) && Number.isNaN(arg);
+}
+function isSet(arg) {
+  return type(arg) === "set";
+}
+function isMap(arg) {
+  return type(arg) === "map";
+}
+function isSymbol(arg) {
+  return type(arg) === "symbol";
+}
+function isObject(arg) {
+  return type(arg) === "object";
+}
+function isDate(arg) {
+  return type(arg) === "date";
+}
+function isRegExp(arg) {
+  return type(arg) === "regexp";
+}
+function isError(arg) {
+  return type(arg) === "error";
+}
+function isFunction(arg) {
+  return type(arg) === "function";
+}
+function isNull(arg) {
+  return type(arg) === "null";
+}
+function isUndefined(arg) {
+  return type(arg) === "undefined";
+}
+function isNil(arg) {
+  return isNull(arg) || isUndefined(arg);
+}
+function isPlainObject(arg) {
+  if (!isObject(arg))
+    return false;
+  const ctor = arg.constructor;
+  if (typeof ctor !== "function")
+    return false;
+  const proto = ctor.prototype;
+  if (!isObject(proto))
+    return false;
+  return proto.hasOwnProperty("isPrototypeOf");
+}
+function isEmpty(arg) {
+  if (isNil(arg))
+    return true;
+  if (isBoolean(arg))
+    return false;
+  if (isNumber(arg))
+    return false;
+  if (isString(arg)) {
+    return arg.length === 0 || whiteSpaceRegx.test(arg);
+  }
+  if (isFunction(arg) || isArray(arg)) {
+    return arg.length === 0;
+  }
+  switch (type(arg)) {
+    case "file":
+    case "map":
+    case "weakmap":
+    case "set":
+    case "weakset": {
+      return arg.size === 0;
+    }
+    case "object": {
+      for (const key in arg) {
+        if (Object.hasOwnProperty.call(arg, key))
+          return false;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+function isValid(arg) {
+  return !isEmpty(arg);
+}
+function isEqual(arg1, arg2) {
+  return String(arg1) === String(arg2);
+}
+function isTrue(arg1) {
+  return arg1 === true || arg1 === "true" || isEqual(arg1, "1");
+}
+function isFalse(arg1) {
+  return arg1 === false || arg1 === "false" || isEqual(arg1, "0");
+}
+function isBool(arg) {
+  return isTrue(arg) || isFalse(arg);
+}
+function isFormData(arg) {
+  return type(arg) === "formdata";
+}
+function uniqueArray(arg) {
+  if (!isValidArray(arg)) {
+    return [];
+  }
+  return Array.from(new Set(arg));
+}
+function isURL(arg) {
+  if (isEmpty(arg)) {
+    return false;
+  }
+  try {
+    const url = new URL(arg);
+    return isValid(url.hostname);
+  } catch (err) {
+    return false;
+  }
+}
+var helper_default = {
+  isUUID,
+  isBoolean,
+  isString,
+  isNumber,
+  isNumeric,
+  isArray,
+  isValidArray,
+  isNan,
+  isSet,
+  isMap,
+  isSymbol,
+  isObject,
+  isDate,
+  isRegExp,
+  isError,
+  isFunction,
+  isNull,
+  isUndefined,
+  isNil,
+  isPlainObject,
+  isEmpty,
+  isValid,
+  isEqual,
+  isTrue,
+  isFalse,
+  isBool,
+  isURL,
+  isFormData,
+  uniqueArray
+};
+
+// src/bytes.ts
+var BYTE = 1;
+var KB = BYTE * 1024;
+var MB = KB * 1024;
+var GB = MB * 1024;
+var TB = GB * 1024;
+var PB = TB * 1024;
+var regx = /^(-?(?:\d+)?\.?\d+)(b|kb|mb|gb|tb|pb)$/i;
+function parseBytes(value) {
+  if (isEmpty(value)) {
+    return;
+  }
+  const str = String(value);
+  const matches = str.match(regx);
+  if (!matches) {
+    return;
+  }
+  const num = parseFloat(matches[1]);
+  const type2 = matches[2].toLowerCase();
+  switch (type2) {
+    case "pb":
+      return num * PB;
+    case "tb":
+      return num * TB;
+    case "gb":
+      return num * GB;
+    case "mb":
+      return num * MB;
+    case "kb":
+      return num * KB;
+    case "b":
+      return num * BYTE;
+  }
+}
+function bytes(size) {
+  return parseBytes(size);
+}
+function formatBytes(value) {
+  const mag = Math.abs(Number(value));
+  let unit;
+  let size;
+  if (mag >= PB) {
+    unit = "PB";
+    size = mag / PB;
+  } else if (mag >= TB) {
+    unit = "TB";
+    size = mag / TB;
+  } else if (mag >= GB) {
+    unit = "GB";
+    size = mag / GB;
+  } else if (mag >= MB) {
+    unit = "MB";
+    size = mag / MB;
+  } else if (mag >= KB) {
+    unit = "KB";
+    size = mag / KB;
+  } else {
+    unit = "B";
+    size = mag / BYTE;
+  }
+  if (String(size).includes(".")) {
+    size = size.toFixed(1);
+  }
+  return size + unit;
+}
+function clone(obj) {
+  return _clone(obj);
+}
+
+// src/color.ts
+var HEX_REGEX = /^#?([0-9A-F]{3}|[0-9A-F]{4}|[0-9A-F]{6}|[0-9A-F]{8})$/i;
+var RGBA_REGEX = /rgba\((\d{1,3}%?),\s*(\d{1,3}%?),\s*(\d{1,3}%?),\s*(\d*(?:\.\d+)?)\)/i;
+var RGB_REGEX = /rgb\((\d{1,3}%?),\s*(\d{1,3}%?),\s*(\d{1,3}%?)\)/i;
+function isHexColor(color) {
+  return HEX_REGEX.test(color);
+}
+function isRgba(color) {
+  return RGBA_REGEX.test(color);
+}
+function isRgb(color) {
+  return RGB_REGEX.test(color);
+}
+function hexToRgb(hex) {
+  if (isEmpty(hex)) {
+    return [];
+  }
+  if (isRgba(hex)) {
+    const [, red2, green2, blue2, alpha3] = RGBA_REGEX.exec(hex);
+    return [Number(red2), Number(green2), Number(blue2), Number(alpha3)];
+  }
+  if (isRgb(hex)) {
+    const [, red2, green2, blue2] = RGB_REGEX.exec(hex);
+    return [Number(red2), Number(green2), Number(blue2), 1];
+  }
+  if (!isHexColor(hex)) {
+    return [];
+  }
+  hex = hex.replace(/^#/, "");
+  if (hex.length === 3) {
+    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+  }
+  let alpha2 = 1;
+  if (hex.length === 8) {
+    alpha2 = hexToFloatAlpha(hex.slice(6, 8));
+    hex = hex.slice(0, 6);
+  }
+  const number = Number.parseInt(hex, 16);
+  const red = number >> 16;
+  const green = number >> 8 & 255;
+  const blue = number & 255;
+  return [red, green, blue, alpha2];
+}
+function isDarkColor(hex) {
+  if (!isHexColor(hex)) {
+    return true;
+  }
+  return colorBrightness(hex) < 170;
+}
+function isLightColor(hex) {
+  return !isDarkColor(hex);
+}
+function colorBrightness(hex) {
+  const [red, green, blue, alpha2] = hexToRgb(hex);
+  return alpha2 * (red * 299 + green * 587 + blue * 114) / 1e3;
+}
+function rgbToHex([r, g, b]) {
+  return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+}
+function alpha(hex, alpha2) {
+  const [red, green, blue] = hexToRgb(hex);
+  return `rgba(${red}, ${green}, ${blue}, ${alpha2})`;
+}
+function lighten(hex, alpha2) {
+  return rgbToHex(alphaHexToRgb(hex, 1 - alpha2, "#fff"));
+}
+function darken(hex, alpha2) {
+  return rgbToHex(alphaHexToRgb(hex, 1 - alpha2, "#010101"));
+}
+function invert(hex) {
+  const [red, green, blue] = hexToRgb(hex);
+  return rgbToHex([255 - red, 255 - green, 255 - blue]);
+}
+function alphaHexToRgb(hex, alpha2, backgroundHex) {
+  const hexRgb = hexToRgb(hex);
+  const backgroundRgb = hexToRgb(backgroundHex);
+  return hexRgb.map((color, index) => {
+    return colorRange(
+      Math.floor(
+        colorRange(color) * alpha2 + colorRange(backgroundRgb[index]) * (1 - alpha2)
+      )
+    );
+  });
+}
+function colorRange(color) {
+  return color < 1 ? 1 : color >= 255 ? 255 : color;
+}
+function hexToFloatAlpha(arg) {
+  const num = parseInt(arg, 16);
+  const max = parseInt("0xff", 16);
+  return Number((num / max).toFixed(2));
+}
+
+// src/conv.ts
+function toBool(value, defaults) {
+  if (isEmpty(value)) {
+    return defaults || false;
+  }
+  if (isBoolean(value)) {
+    return value;
+  }
+  return isTrue(value);
+}
+
+// src/hs.ts
+var second = 1;
+var minute = second * 60;
+var hour = minute * 60;
+var day = hour * 24;
+var week = day * 7;
+var year = day * 365;
+var regx2 = /^(-?(?:\d+)?\.?\d+)(s|m|h|d|w|y)$/i;
+function parse(arg) {
+  if (isEmpty(arg)) {
+    return;
+  }
+  const str = String(arg);
+  const matches = str.match(regx2);
+  if (!matches) {
+    return;
+  }
+  const num = parseFloat(matches[1]);
+  const type2 = matches[2].toLowerCase();
+  switch (type2) {
+    case "y":
+      return num * year;
+    case "w":
+      return num * week;
+    case "d":
+      return num * day;
+    case "h":
+      return num * hour;
+    case "m":
+      return num * minute;
+    case "s":
+      return num * second;
+  }
+}
+function hs(arg) {
+  const value = parse(arg);
+  if (value) {
+    return Math.round(value);
+  }
+}
+function ms(arg) {
+  const value = hs(arg);
+  if (value) {
+    return value * 1e3;
+  }
+}
+function timestamp() {
+  return Math.floor(Date.now() / 1e3);
+}
+function date(str, format) {
+  return dayjs(str, format);
+}
+function unixDate(t) {
+  return dayjs.unix(t);
+}
+function isDateExpired(start, end, expire) {
+  return end - start > hs(expire);
+}
+function unixDiff(start, end, unit = "day") {
+  if (start > end || start < 0 || end < 0) {
+    return 0;
+  }
+  return unixDate(end).diff(unixDate(start), unit);
+}
+function datePeriod(start, value = 1, unit = "month") {
+  return unixDate(start).add(value, unit).unix();
+}
+var commonImageMimeTypes = [
+  m.lookup(".jpg"),
+  m.lookup(".png"),
+  m.lookup(".bmp"),
+  m.lookup(".gif")
+];
+var commonFileMimeTypes = [
+  ...commonImageMimeTypes,
+  m.lookup(".txt"),
+  m.lookup(".md"),
+  m.lookup(".doc"),
+  m.lookup(".docx"),
+  m.lookup(".xls"),
+  m.lookup(".xlsx"),
+  m.lookup(".csv"),
+  m.lookup(".ppt"),
+  m.lookup(".pptx"),
+  m.lookup(".pdf"),
+  m.lookup(".mp4"),
+  m.lookup(".wmv")
+];
+var mime = m.lookup;
+var NANOID_ALPHABET = "ModuleSymbhasOwnPr0123456789ABCDEFGHNRVfgctiUvzKqYTJkLxpZXIjQW";
+function nanoid(len = 21) {
+  return nanoidCustomAlphabet(NANOID_ALPHABET, len);
+}
+function nanoidCustomAlphabet(alphabet, len = 21) {
+  const generate = customAlphabet(alphabet, len);
+  return generate();
+}
+function pickObject(target, fields, excludes = []) {
+  if (!isObject(target)) {
+    return {};
+  }
+  const copied = clone(target);
+  const targetKeys = Object.keys(copied);
+  const fieldAlias = {};
+  let picked = [];
+  if (fields.length > 0) {
+    fields.forEach((item) => {
+      if (isArray(item)) {
+        if (item.length > 0) {
+          const filed = item[0];
+          picked.push(filed);
+          if (item.length > 1) {
+            fieldAlias[filed] = item[1];
+          }
+        }
+      } else {
+        picked.push(item);
+      }
+    });
+  } else {
+    picked = targetKeys;
+  }
+  const newObj = {};
+  targetKeys.filter((key) => !excludes.includes(key) && picked.includes(key)).forEach((key) => {
+    const alias = fieldAlias[key];
+    if (alias) {
+      newObj[alias] = copied[key];
+    } else {
+      newObj[key] = copied[key];
+    }
+  });
+  return newObj;
+}
+function pickValidValues(target, fields) {
+  const dist = {};
+  fields.forEach((field) => {
+    let key = String(field);
+    let alias;
+    if (isArray(field)) {
+      key = field[0];
+      if (field.length > 1) {
+        alias = field[1];
+      }
+    }
+    let value = target[key];
+    if (isValid(value)) {
+      if (isPlainObject(value) || isArray(value)) {
+        value = clone(value);
+      }
+      dist[alias || key] = value;
+    }
+  });
+  return dist;
+}
+function removeObjectNil(target) {
+  if (!isObject(target)) {
+    return {};
+  }
+  const copied = clone(target);
+  const newObj = {};
+  for (const field of Object.keys(copied)) {
+    const value = copied[field];
+    if (isNil(value) || isNan(value)) {
+      continue;
+    }
+    newObj[field] = value;
+  }
+  return newObj;
+}
+function copyObjectValues(target, dist, keyMaps) {
+  if (!isObject(target) || !isObject(dist)) {
+    return;
+  }
+  for (const keys of keyMaps) {
+    let targetKey;
+    let distKey;
+    if (isArray(keys)) {
+      targetKey = keys[0];
+      distKey = keys[1];
+    } else {
+      targetKey = String(keys);
+      distKey = targetKey;
+    }
+    let value = objectPath.get(target, targetKey);
+    if (!isNil(value) && !isNan(value)) {
+      if (isPlainObject(value) || isArray(value)) {
+        value = clone(value);
+      }
+      objectPath.set(dist, distKey, value);
+    }
+  }
+}
+
+// src/parse.ts
+function parseJson(str, defaultValue) {
+  let value;
+  try {
+    value = JSON.parse(str);
+  } catch (e) {
+  }
+  if (defaultValue && !value) {
+    value = defaultValue;
+  }
+  return value;
+}
+function parseBool(arg, defaultValue) {
+  if (isEmpty(arg)) {
+    return defaultValue || false;
+  }
+  if (isBoolean(arg)) {
+    return arg;
+  }
+  return isTrue(arg);
+}
+function parseNumber(arg, defaultValue, maxValue) {
+  if (isNumber(arg)) {
+    if (maxValue && maxValue < Number(arg)) {
+      return maxValue;
+    }
+    return Number(arg);
+  }
+  const num = parseInt(arg, 10);
+  if (isNaN(num)) {
+    return defaultValue;
+  }
+  if (maxValue && maxValue < num) {
+    return maxValue;
+  }
+  return num;
+}
+function htmlToText(html, limit = 100) {
+  let result = html.replace(/<style[^<>]*>((?!<\/).)*<\/style>/gi, "").replace(/<script[^<>]*>((?!<\/).)*<\/script>/gi, "").replace(/<[^>]+>/g, "").replace(/\t|\r|\n|\r\n/g, "").replace(/\s+/g, "").replace(/&nbsp;/g, " ").replace(/&quot;/g, '"').replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+  if (limit > 0) {
+    result = result.slice(0, limit);
+  }
+  return result;
+}
+
+// src/qs.ts
+function stringify(arg, options) {
+  const arr = [];
+  Object.keys(arg).forEach((key) => {
+    let val = arg[key];
+    if (isEmpty(val)) {
+      val = "";
+    } else {
+      val = String(val);
+    }
+    if (options?.encode) {
+      val = encodeURIComponent(val);
+    }
+    arr.push(`${key}=${val}`);
+  });
+  return arr.join("&");
+}
+function parse2(str, options) {
+  const obj = {};
+  if (!isString(str)) {
+    return obj;
+  }
+  const arr = str.replace(/^([^?]+)?\?/, "").split("&");
+  arr.forEach((param) => {
+    const paramArr = param.split("=");
+    const key = paramArr[0];
+    if (!isEmpty(key)) {
+      let val = paramArr[1];
+      if (options?.decode) {
+        val = decodeURIComponent(val);
+      }
+      val = options?.separator && val.includes(options?.separator) ? val.split(options?.separator) : val;
+      obj[key] = val;
+    }
+  });
+  return obj;
+}
+var qs_default = {
+  stringify,
+  parse: parse2
+};
+
+// src/random.ts
+var numeric = "0123456789";
+var hexic = "0123456789abcdef";
+var lower = "abcdefghijklmnopqrstuvwxyz";
+var upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var length = 6;
+var RandomType = /* @__PURE__ */ ((RandomType2) => {
+  RandomType2[RandomType2["LOWER"] = 0] = "LOWER";
+  RandomType2[RandomType2["UPPER"] = 1] = "UPPER";
+  RandomType2[RandomType2["NUMERIC"] = 2] = "NUMERIC";
+  RandomType2[RandomType2["HEXIC"] = 3] = "HEXIC";
+  RandomType2[RandomType2["LOWER_NUMERIC"] = 4] = "LOWER_NUMERIC";
+  RandomType2[RandomType2["UPPER_NUMERIC"] = 5] = "UPPER_NUMERIC";
+  RandomType2[RandomType2["ALPHANUMERIC"] = 6] = "ALPHANUMERIC";
+  return RandomType2;
+})(RandomType || {});
+function random(len = length * 2, type2 = 6 /* ALPHANUMERIC */) {
+  let alphabet = numeric + lower + upper;
+  switch (type2) {
+    case 0 /* LOWER */:
+      alphabet = lower;
+      break;
+    case 1 /* UPPER */:
+      alphabet = upper;
+      break;
+    case 3 /* HEXIC */:
+      alphabet = hexic;
+      break;
+    case 2 /* NUMERIC */:
+      alphabet = numeric;
+      break;
+    case 4 /* LOWER_NUMERIC */:
+      alphabet = lower + numeric;
+      break;
+    case 5 /* UPPER_NUMERIC */:
+      alphabet = upper + numeric;
+      break;
+    case 6 /* ALPHANUMERIC */:
+      alphabet = lower + upper + numeric;
+      break;
+  }
+  let str = "";
+  const alphabetLength = alphabet.length;
+  for (let i = 0; i < len; i++) {
+    str += alphabet.charAt(Math.floor(Math.random() * alphabetLength));
+  }
+  return str;
+}
+function slugify(text) {
+  return slug(text);
+}
+
+export { RandomType, alpha, alphaHexToRgb, bytes, clone, colorBrightness, commonFileMimeTypes, commonImageMimeTypes, copyObjectValues, darken, date, datePeriod, formatBytes, helper_default as helper, hexToRgb, hs, htmlToText, invert, isDarkColor, isDateExpired, isHexColor, isLightColor, isRgb, isRgba, lighten, mime, ms, nanoid, nanoidCustomAlphabet, parseBool, parseBytes, parseJson, parseNumber, pickObject, pickValidValues, qs_default as qs, random, removeObjectNil, rgbToHex, slugify, timestamp, toBool, type, unixDate, unixDiff };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map