@oeos-components/utils 0.0.21 → 0.0.22

package/dist/base.mjs

@@ -0,0 +1,655 @@
+import { unref, isRef, toRaw } from '@vue/reactivity';
+import { consola } from 'consola';
+import { cloneDeep } from 'es-toolkit';
+import { ElMessage, ElMessageBox } from 'element-plus';
+
+function $toast(message, type = "success", otherParams = {}) {
+  const typeMap = {
+    s: "success",
+    i: "info",
+    e: "error",
+    w: "warning"
+  };
+  function isShortType(t) {
+    return ["s", "i", "e", "w"].includes(t);
+  }
+  function isToastOptions(obj) {
+    return typeof obj === "object" && obj !== null;
+  }
+  if (isToastOptions(message)) {
+    if (message.closeAll) {
+      ElMessage.closeAll();
+    }
+    message.customClass = message.customClass === "el" ? "" : "o-antd-message";
+    ElMessage(message);
+    return;
+  }
+  if (isToastOptions(type)) {
+    if (type.closeAll) {
+      ElMessage.closeAll();
+    }
+    type.customClass = type.customClass === "el" ? "" : "o-antd-message";
+    ElMessage({
+      message,
+      type: "success",
+      ...type
+    });
+    return;
+  }
+  if (otherParams.closeAll) {
+    ElMessage.closeAll();
+  }
+  const resolvedType = isShortType(type) ? typeMap[type] : type;
+  otherParams.customClass = otherParams.customClass === "el" ? "" : "o-antd-message";
+  ElMessage({
+    message,
+    type: resolvedType,
+    ...otherParams
+  });
+}
+$toast.success = (message, otherParams = {}) => $toast(message, "success", otherParams);
+$toast.info = (message, otherParams = {}) => $toast(message, "info", otherParams);
+$toast.error = (message, otherParams = {}) => $toast(message, "error", otherParams);
+$toast.warning = (message, otherParams = {}) => $toast(message, "warning", otherParams);
+function setStorage(storageName, params, isSession = false) {
+  let handleParams;
+  if (typeof params === "number" || typeof params === "string") {
+    handleParams = params;
+  } else {
+    handleParams = JSON.stringify(params);
+  }
+  if (isSession) {
+    sessionStorage.setItem(storageName, handleParams);
+  } else {
+    localStorage.setItem(storageName, handleParams);
+  }
+}
+function getStorage(data, isSession = false) {
+  let getLocalData = "";
+  let getSessionData = "";
+  if (isSession) {
+    getSessionData = sessionStorage.getItem(data);
+  } else {
+    getLocalData = localStorage.getItem(data);
+  }
+  if (getLocalData) {
+    try {
+      if (typeof JSON.parse(getLocalData) !== "number") {
+        getLocalData = JSON.parse(getLocalData);
+      }
+    } catch (e) {
+    }
+    return getLocalData;
+  } else if (getSessionData) {
+    try {
+      if (typeof JSON.parse(getSessionData) !== "number") {
+        getSessionData = JSON.parse(getSessionData);
+      }
+    } catch (e) {
+    }
+    return getSessionData;
+  }
+  return null;
+}
+function clearStorage(str = "") {
+  if (isEmpty(str)) {
+    sessionStorage.clear();
+    localStorage.clear();
+  }
+  if (notEmpty(str) && getType(str) !== "object") {
+    let strArr = Array.isArray(str) ? str : [str];
+    for (let i = 0; i < strArr.length; i++) {
+      sessionStorage.removeItem(strArr[i]);
+      localStorage.removeItem(strArr[i]);
+    }
+  }
+  if (_isObjectWithExclude(str)) {
+    if (notEmpty(str.exclude) && getType(str) === "object") {
+      let sessionStorageObj = {};
+      let localStorageObj = {};
+      for (const key in str.exclude) {
+        if (Object.prototype.hasOwnProperty.call(str.exclude, key)) {
+          const name = str.exclude[key];
+          if (getStorage(name)) {
+            localStorageObj[name] = getStorage(name);
+          }
+          if (getStorage(name, true)) {
+            sessionStorageObj[name] = getStorage(name, true);
+          }
+        }
+      }
+      sessionStorage.clear();
+      localStorage.clear();
+      for (const key in sessionStorageObj) {
+        setStorage(key, sessionStorageObj[key], true);
+      }
+      for (const key in localStorageObj) {
+        setStorage(key, localStorageObj[key]);
+      }
+    }
+  }
+}
+function _isObjectWithExclude(obj) {
+  return typeof obj === "object" && obj !== null && "exclude" in obj && typeof obj.exclude === "object";
+}
+function validForm(ref, { message = "\u8868\u5355\u6821\u9A8C\u9519\u8BEF, \u8BF7\u68C0\u67E5", detail = false, showMessage = true } = {}) {
+  return new Promise((resolve, reject) => {
+    unref(ref).validate((valid, status) => {
+      if (valid) {
+        resolve(status);
+      } else {
+        if (message && showMessage) {
+          let errorText = Object.keys(status);
+          let toastMessage = message;
+          if (detail) {
+            toastMessage = message + errorText.join(",");
+          }
+          $toast(toastMessage, "e");
+        }
+        reject(status);
+      }
+    });
+  });
+}
+function isEmpty(data, strict = false) {
+  if (isRef(data)) {
+    data = unref(data);
+  }
+  if (strict) {
+    if (data === false || data === 0 || data === BigInt(0)) {
+      return false;
+    }
+  }
+  if (data == null) return true;
+  if (data instanceof Date) {
+    return isNaN(data.getTime());
+  }
+  switch (typeof data) {
+    case "string":
+      return data.trim().length === 0;
+    case "boolean":
+      return !data;
+    case "number":
+      return 0 === data || isNaN(data);
+    // ❗ `NaN`或者0 被认为是空
+    case "symbol":
+      return false;
+    case "bigint":
+      return data === BigInt(0);
+  }
+  if (data instanceof Map || data instanceof Set) return data.size === 0;
+  if (Array.isArray(data) || typeof data.length === "number" && Object.prototype.toString.call(data) === "[object Object]") {
+    return data.length === 0;
+  }
+  if (typeof data === "object") {
+    return Object.keys(data).length === 0;
+  }
+  return false;
+}
+function notEmpty(v) {
+  return !isEmpty(v);
+}
+function merge(obj1, obj2) {
+  let merged = { ...obj1, ...obj2 };
+  for (let key in merged) {
+    if (!isEmpty(obj1[key]) && !isEmpty(obj2[key])) {
+      merged[key] = obj2[key];
+    } else if (isEmpty(obj1[key]) && !isEmpty(obj2[key])) {
+      merged[key] = obj2[key];
+    } else if (!isEmpty(obj1[key]) && isEmpty(obj2[key])) {
+      merged[key] = obj1[key];
+    }
+  }
+  return merged;
+}
+function clone(data, times = 1) {
+  if (isRef(data)) {
+    data = unref(data);
+  }
+  if (getType(data) !== "array") {
+    return cloneDeep(data);
+  }
+  const clonedData = cloneDeep(data);
+  const result = [];
+  for (let i = 0; i < times; i++) {
+    result.push(...clonedData);
+  }
+  return result;
+}
+function uuid(type = "", length = 4, options = {}) {
+  const { emailStr = "@qq.com", timeStr = "{y}-{m}-{d} {h}:{i}:{s}", startStr = "", optionsIndex = null } = options;
+  function isRef2(obj) {
+    return obj && typeof obj === "object" && obj._isRef === true;
+  }
+  function unref2(ref) {
+    return isRef2(ref) ? ref.value : ref;
+  }
+  function random2(min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+  }
+  type = unref2(type);
+  if (Array.isArray(type)) {
+    if (type.length === 0) return "";
+    const randIndex = optionsIndex ?? random2(0, type.length - 1);
+    const selectedItem = type[randIndex];
+    if (typeof selectedItem === "object" && selectedItem !== null && "value" in selectedItem) {
+      return selectedItem.value;
+    }
+    return selectedItem;
+  }
+  let randomChars = "ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678";
+  let result = startStr;
+  if (type === "phone") {
+    const prefixes = ["130", "131", "132", "133", "135", "136", "137", "138", "170", "187", "189"];
+    result = prefixes[random2(0, prefixes.length - 1)];
+    for (let i = 0; i < 8; i++) {
+      result += Math.floor(Math.random() * 10);
+    }
+    return result;
+  }
+  if (type === "email") {
+    result = uuid(startStr, length) + emailStr;
+    return result;
+  }
+  if (type === "time") {
+    return uuid(startStr, length, options) + " " + formatTime(/* @__PURE__ */ new Date(), timeStr);
+  }
+  if (type === "number") {
+    const numChars = "123456789";
+    result = "";
+    for (let i = 0; i < length; i++) {
+      result += numChars[random2(0, numChars.length - 1)];
+    }
+    return Number(result);
+  }
+  if (type === "ip") {
+    const randomNum = random2(1, 99);
+    return `10.0.11.${randomNum}`;
+  }
+  if (type === "port") {
+    return random2(1, 65535);
+  }
+  for (let i = 0; i < length; i++) {
+    result += randomChars[random2(0, randomChars.length - 1)];
+  }
+  return result;
+}
+function getType(type) {
+  if (typeof type === "object") {
+    const objType = Object.prototype.toString.call(type).slice(8, -1).toLowerCase();
+    return objType;
+  } else {
+    return typeof type;
+  }
+}
+function sleep(delay = 0, fn) {
+  return new Promise(
+    (resolve) => setTimeout(() => {
+      fn?.();
+      resolve();
+    }, delay)
+  );
+}
+function validateTrigger(type = "required", rules = {}, pureValid = false) {
+  let mergeRules = {
+    trigger: ["blur", "change"],
+    ...rules
+  };
+  return validate(type, mergeRules, pureValid);
+}
+var ValidateType = /* @__PURE__ */ ((ValidateType2) => {
+  ValidateType2["REQUIRED"] = "required";
+  ValidateType2["PASSWORD"] = "password";
+  ValidateType2["NUMBER"] = "number";
+  ValidateType2["POSITIVE"] = "positive";
+  ValidateType2["ZERO_POSITIVE"] = "zeroPositive";
+  ValidateType2["INTEGER"] = "integer";
+  ValidateType2["DECIMAL"] = "decimal";
+  ValidateType2["MOBILE"] = "mobile";
+  ValidateType2["EMAIL"] = "email";
+  ValidateType2["IP"] = "ip";
+  ValidateType2["PORT"] = "port";
+  ValidateType2["BETWEEN"] = "between";
+  ValidateType2["LENGTH"] = "length";
+  ValidateType2["SAME"] = "same";
+  ValidateType2["CUSTOM"] = "custom";
+  return ValidateType2;
+})(ValidateType || {});
+function validate(type = "required", rules = {}, pureValid = false) {
+  let trigger = rules.trigger || [];
+  const typeMaps = Object.values(ValidateType);
+  let parseRequired = rules.required ?? true;
+  if (!typeMaps.includes(type)) {
+    return {
+      required: parseRequired,
+      message: type,
+      trigger
+    };
+  }
+  if (type === "required" /* REQUIRED */) {
+    return {
+      required: parseRequired,
+      message: rules.message ?? "\u8BF7\u8F93\u5165",
+      trigger
+    };
+  }
+  if (type === "password" /* PASSWORD */) {
+    const validateName = (rule, value, callback) => {
+      let validFlag = /^[a-zA-Z0-9_-]+$/.test(value);
+      if (!validFlag) {
+        callback(new Error(rules.message || "\u5BC6\u7801\u53EA\u80FD\u7531\u82F1\u6587\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u3001\u4E2D\u5212\u7EBF\u7EC4\u6210"));
+      } else {
+        callback();
+      }
+    };
+    return {
+      validator: validateName,
+      trigger
+    };
+  }
+  if (type === "positive" /* POSITIVE */ || type === "number" /* NUMBER */) {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u6B63\u6574\u6570", pureValid, /^[1-9]+\d*$/);
+  }
+  if (type === "zeroPositive" /* ZERO_POSITIVE */) {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u975E\u8D1F\u6574\u6570", pureValid, /^(0|[1-9]+\d*)$/);
+  }
+  if (type === "integer" /* INTEGER */) {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u6574\u6570", pureValid, /^(0|[-]?[1-9]\d*)$/);
+  }
+  if (type === "decimal" /* DECIMAL */) {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u975E\u8D1F\u6570\u5B57, \u5305\u542B\u5C0F\u6570\u4E14\u6700\u591A2\u4F4D", pureValid, /(0|[1-9]\d*)(\.\d{1, 2})?|0\.\d{1,2}/);
+  }
+  if (type === "mobile" /* MOBILE */) {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u6B63\u786E\u7684\u624B\u673A\u53F7", pureValid, /^[1][0-9]{10}$/);
+  }
+  if (type === "email" /* EMAIL */) {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u6B63\u786E\u7684email", pureValid, /^[^\s@]+@[^\s@]+\.[^\s@]+$/);
+  }
+  if (type === "ip" /* IP */) {
+    return _validValue(
+      rules,
+      "\u8BF7\u8F93\u5165\u6B63\u786E\u7684ip\u5730\u5740",
+      pureValid,
+      /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/
+    );
+  }
+  if (type === "port" /* PORT */) {
+    return _validValue(
+      rules,
+      "\u8BF7\u8F93\u51651-65535\u7684\u7AEF\u53E3\u53F7",
+      pureValid,
+      /^([1-9]|[1-9][0-9]{1,3}|[1-5][0-9]{4}|6[0-5][0-5][0-3][0-5])$/
+    );
+  }
+  if (type === "between" /* BETWEEN */) {
+    let min = rules.min;
+    let max = rules.max;
+    const validateBetween = (rule, value, callback) => {
+      let validFlag = /^-?[0-9]+$/.test(value);
+      if (!validFlag) {
+        callback(new Error("\u8BF7\u8F93\u5165\u6570\u5B57"));
+      }
+      if (value < min && min !== void 0) {
+        callback(new Error(`\u6570\u5B57\u4E0D\u80FD\u5C0F\u4E8E${min}`));
+      }
+      if (value > max && max !== void 0) {
+        callback(new Error(`\u6570\u5B57\u4E0D\u80FD\u5927\u4E8E${max}`));
+      }
+      callback();
+    };
+    return {
+      validator: validateBetween,
+      trigger,
+      required: parseRequired
+    };
+  }
+  if (type === "length" /* LENGTH */) {
+    return {
+      min: rules.min,
+      max: rules.max,
+      message: rules.message ?? `\u8BF7\u8F93\u5165${rules.min}\u5230${rules.max}\u4E2A\u5B57\u7B26`,
+      trigger,
+      required: parseRequired
+    };
+  }
+  if (type === "same" /* SAME */) {
+    const validateSame = (rule, value, callback) => {
+      let isSame = value === rules.value;
+      if (!isSame) {
+        const errMessage = rules.message || "\u5BC6\u7801\u548C\u786E\u8BA4\u5BC6\u7801\u8981\u4E00\u81F4";
+        callback(new Error(errMessage));
+      }
+      if (parseRequired && !value) {
+        callback(new Error(rules.message || "\u8BF7\u8F93\u5165"));
+      }
+      callback();
+    };
+    let res = {
+      validator: validateSame,
+      trigger,
+      required: parseRequired
+    };
+    return res;
+  }
+  if (type === "custom" /* CUSTOM */) {
+    if (pureValid) {
+      return _validValue(rules.value, rules.message, pureValid, rules.reg);
+    } else {
+      return _validValue(rules, rules.message, pureValid, rules.reg);
+    }
+  }
+  function _validValue(rules2, msg, pureValid2, reg) {
+    if (pureValid2 === true) {
+      return reg.test(rules2);
+    }
+    const validatePhone = (rule, value, callback) => {
+      let validFlag = reg.test(value);
+      if (!validFlag) {
+        callback(new Error(rules2.message ?? msg));
+      } else {
+        callback();
+      }
+    };
+    return {
+      validator: validatePhone,
+      required: rules2.required ?? true,
+      trigger
+    };
+  }
+}
+async function asyncWrapper(func, ...args) {
+  try {
+    const res = await func(...args);
+    return { res };
+  } catch (err) {
+    return { err };
+  }
+}
+const copy = (text, toastParams = {}) => {
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.style.position = "fixed";
+  document.body.appendChild(textarea);
+  textarea.select();
+  document.execCommand("copy");
+  document.body.removeChild(textarea);
+  if (!toastParams.hideToast) {
+    const { hideToast, ...toastOptions } = toastParams;
+    $toast(text + "\u590D\u5236\u6210\u529F", toastOptions);
+    return true;
+  }
+  return true;
+};
+function log(variableStr, variable, otherInfo = "") {
+  const stack = new Error().stack.split("\n")[2].trim();
+  const matchResult = stack.match(/\((.*):(\d+):(\d+)\)/);
+  let fileInfo = "";
+  try {
+    if (matchResult && otherInfo) {
+      const lineNumber = matchResult[2];
+      fileInfo = `vscode://file${JSON.parse(otherInfo)}:${lineNumber}`;
+    }
+  } catch (error) {
+    fileInfo = otherInfo;
+  }
+  if (isRef(variable)) {
+    let unrefVariable = unref(variable);
+    _log(toRaw(unrefVariable));
+  } else {
+    _log(variable);
+  }
+  function _log(consoleData) {
+    if (getType2(consoleData) === "object" || getType2(consoleData) === "array") {
+      consola.log(
+        `%c${variableStr} `,
+        "background:#fff; color: blue;font-size: 0.8em",
+        JSON.stringify(consoleData, null, "	"),
+        `${fileInfo}`
+      );
+    } else {
+      consola.log(`%c${variableStr} `, "background:#fff; color: blue;font-size: 0.8em", consoleData, `${fileInfo}`);
+    }
+  }
+  function getType2(type) {
+    if (typeof type === "object") {
+      const objType = Object.prototype.toString.call(type).slice(8, -1).toLowerCase();
+      return objType;
+    } else {
+      return typeof type;
+    }
+  }
+}
+function random(min = 0, max = 10) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function toLine(text, connect = "-") {
+  let translateText = text.replace(/([A-Z])/g, (match, p1, offset, origin) => {
+    if (offset === 0) {
+      return `${match.toLocaleLowerCase()}`;
+    } else {
+      return `${connect}${match.toLocaleLowerCase()}`;
+    }
+  }).toLocaleLowerCase();
+  return translateText;
+}
+function processWidth(initValue, isBase = false) {
+  let value = unref(initValue);
+  let res = "";
+  if (!value) {
+    return isBase ? value : {};
+  } else if (typeof value === "number") {
+    value = String(value);
+  }
+  if (value === "") {
+    return isBase ? value : {};
+  } else if (typeof value === "string" && !isNaN(value)) {
+    res = value + "px";
+  } else if (typeof value === "string" && /^[0-9]+(\.[0-9]+)?(px|%|em|rem|vw|vh|ch)*$/.test(value)) {
+    res = value;
+  } else {
+    console.warn(`${value} is Invalid unit provided`);
+    return value;
+  }
+  if (isBase) {
+    return res;
+  }
+  return { width: res };
+}
+function throttle(fn, delay = 1e3) {
+  let last = 0;
+  let timer = null;
+  return function() {
+    let context = this;
+    let args = arguments;
+    let now = +/* @__PURE__ */ new Date();
+    if (now - last < delay) {
+      clearTimeout(timer);
+      timer = setTimeout(function() {
+        last = now;
+        fn.apply(context, args);
+      }, delay);
+    } else {
+      last = now;
+      fn.apply(context, args);
+    }
+  };
+}
+function tryCatch(promise, sendLoading) {
+  const updateLoading = (value) => {
+    if (isRef(sendLoading)) {
+      sendLoading.value = value;
+    } else if (sendLoading !== null) {
+      console.warn("Cannot modify non-ref sendLoading directly!");
+    }
+  };
+  updateLoading(true);
+  return promise.then((data) => {
+    updateLoading(false);
+    return { data, error: null };
+  }).catch((error) => {
+    updateLoading(false);
+    return { data: null, error };
+  });
+}
+function debounce(func, delay = 500, immediate, resultCallback) {
+  let timer = null;
+  let isInvoke = false;
+  const _debounce = function(...args) {
+    return new Promise((resolve, reject) => {
+      if (timer) clearTimeout(timer);
+      if (immediate && !isInvoke) {
+        try {
+          const result = func.apply(this, args);
+          if (resultCallback) resultCallback(result);
+          resolve(result);
+        } catch (e) {
+          reject(e);
+        }
+        isInvoke = true;
+      } else {
+        timer = setTimeout(() => {
+          try {
+            const result = func.apply(this, args);
+            if (resultCallback) resultCallback(result);
+            resolve(result);
+          } catch (e) {
+            reject(e);
+          }
+          isInvoke = false;
+          timer = null;
+        }, delay);
+      }
+    });
+  };
+  _debounce.cancel = function() {
+    if (timer) clearTimeout(timer);
+    isInvoke = false;
+    timer = null;
+  };
+  return _debounce;
+}
+function confirm(message, options) {
+  const resolvedMessage = typeof message === "function" ? message() : message;
+  const elContext = ElMessageBox.install?.context || ElMessageBox._context || document.querySelector("#app")?._vue_app?._context;
+  const mergeOptions = {
+    title: "\u63D0\u793A",
+    draggable: true,
+    showCancelButton: false,
+    confirmButtonText: "\u786E\u5B9A",
+    dangerouslyUseHTMLString: true,
+    // 允许 HTML
+    appContext: elContext,
+    // 强制注入 Element Plus 的上下文
+    ...options
+  };
+  return ElMessageBox.confirm(resolvedMessage, mergeOptions);
+}
+function getVariable(propertyName) {
+  let res = getComputedStyle(document.documentElement).getPropertyValue(propertyName).trim();
+  return res;
+}
+function test() {
+  return "\u54C8\u54C8\u54C8" + /* @__PURE__ */ new Date();
+}
+
+export { $toast, asyncWrapper, clearStorage, clone, confirm, copy, debounce, getStorage, getType, getVariable, isEmpty, log, merge, notEmpty, processWidth, random, setStorage, sleep, test, throttle, toLine, tryCatch, uuid, validForm, validate, validateTrigger };

package/dist/day.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+const dayjs = require('dayjs');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const dayjs__default = /*#__PURE__*/_interopDefaultCompat(dayjs);
+
+function formatDate(date, format = "YYYY-MM-DD HH:mm:ss") {
+  return dayjs__default(date || /* @__PURE__ */ new Date()).format(format);
+}
+const formatDateToDay = (date) => formatDate(date, "YYYY-MM-DD");
+const formatDateToMinute = (date) => formatDate(date, "YYYY-MM-DD HH:mm");
+function diffDate(date1, date2 = dayjs__default(), format = "second") {
+  if (!date1) return;
+  return dayjs__default(date1).diff(dayjs__default(date2), format);
+}
+function diffDateFromCurrent(second) {
+  if (second >= 60 * 60 * 24 * 365) {
+    return `${parseInt(String(second / (60 * 60 * 24 * 365)))}\u5E74\u524D`;
+  }
+  if (second >= 60 * 60 * 24 * 30) {
+    return `${parseInt(String(second / (60 * 60 * 24 * 30)))}\u6708\u524D`;
+  }
+  if (second >= 60 * 60 * 24) {
+    return `${parseInt(String(second / (60 * 60 * 24)))}\u5929\u524D`;
+  }
+  if (second >= 60 * 60) {
+    return `${parseInt(String(second / (60 * 60)))}\u5C0F\u65F6\u524D`;
+  }
+  if (second >= 60) {
+    return `${parseInt(String(second / 60))}\u5206\u949F\u524D`;
+  }
+  return `${parseInt(String(second))}\u79D2\u524D`;
+}
+
+exports.diffDate = diffDate;
+exports.diffDateFromCurrent = diffDateFromCurrent;
+exports.formatDate = formatDate;
+exports.formatDateToDay = formatDateToDay;
+exports.formatDateToMinute = formatDateToMinute;