@central-design-system/components 3.0.0-alpha.2 → 3.0.0-alpha.4

package/src/utils/date.ts

@@ -0,0 +1,1100 @@
+import { isDate, pad } from '@components/utils';
+import defaultLang from '@components/locale/ru';
+
+import type { ILocale } from '@components/locale';
+
+export interface IRawDate {
+  year?: number;
+  month?: number;
+  day?: number;
+  hour?: number;
+  minute?: number;
+  second?: number;
+  millisecond?: number;
+  timezoneOffset?: number;
+  dateHash?: string;
+  timeHash?: string;
+  date?: number;
+}
+
+export type TDateLocale = ILocale['date'];
+
+const MILLISECONDS_IN_DAY: number = 86400000;
+const MILLISECONDS_IN_HOUR: number = 3600000;
+const MILLISECONDS_IN_MINUTE: number = 60000;
+const defaultMask: string = 'YYYY-MM-DDTHH:mm:ss.SSSZ';
+const token: RegExp =
+  /\[((?:[^\]\\]|\\]|\\)*)\]|d{1,4}|M{1,4}|m{1,2}|w{1,2}|Qo|Do|D{1,4}|YY(?:YY)?|H{1,2}|h{1,2}|s{1,2}|S{1,3}|Z{1,2}|a{1,2}|[AQExX]/g;
+const reverseToken: RegExp =
+  /(\[[^\]]*\])|d{1,4}|M{1,4}|m{1,2}|w{1,2}|Qo|Do|D{1,4}|YY(?:YY)?|H{1,2}|h{1,2}|s{1,2}|S{1,3}|Z{1,2}|a{1,2}|[AQExX]|([.*+:?^,\s${}()|\\]+)/g;
+const regexStore: Record<string, any> = {};
+
+const formatter: Record<string, Function> = {
+  // Year: 00, 01, ..., 99
+  YY(date: Date, dateLocale: TDateLocale, forcedYear: number) {
+    // workaround for < 1900 with new Date()
+    const y = this.YYYY(date, dateLocale, forcedYear) % 100;
+    return y >= 0 ? pad(y) : '-' + pad(Math.abs(y));
+  },
+
+  // Year: 1900, 1901, ..., 2099
+  YYYY(date: Date, _dateLocale: TDateLocale, forcedYear: number) {
+    // workaround for < 1900 with new Date()
+    return forcedYear !== void 0 && forcedYear !== null ? forcedYear : date.getFullYear();
+  },
+
+  // Month: 1, 2, ..., 12
+  M(date: Date) {
+    return date.getMonth() + 1;
+  },
+
+  // Month: 01, 02, ..., 12
+  MM(date: Date) {
+    return pad(date.getMonth() + 1);
+  },
+
+  // Month Short Name: Jan, Feb, ...
+  MMM(date: Date, dateLocale: TDateLocale) {
+    return dateLocale.monthsShort[date.getMonth()];
+  },
+
+  // Month Name: January, February, ...
+  MMMM(date: Date, dateLocale: TDateLocale) {
+    return dateLocale.months[date.getMonth()];
+  },
+
+  // Quarter: 1, 2, 3, 4
+  Q(date: Date) {
+    return Math.ceil((date.getMonth() + 1) / 3);
+  },
+
+  // Quarter: 1st, 2nd, 3rd, 4th
+  Qo(date: Date) {
+    return getOrdinal(this.Q(date));
+  },
+
+  // Day of month: 1, 2, ..., 31
+  D(date: Date) {
+    return date.getDate();
+  },
+
+  // Day of month: 1st, 2nd, ..., 31st
+  Do(date: Date) {
+    return getOrdinal(date.getDate());
+  },
+
+  // Day of month: 01, 02, ..., 31
+  DD(date: Date) {
+    return pad(date.getDate());
+  },
+
+  // Day of year: 1, 2, ..., 366
+  DDD(date: Date) {
+    return getDayOfYear(date);
+  },
+
+  // Day of year: 001, 002, ..., 366
+  DDDD(date: Date) {
+    return pad(getDayOfYear(date) as number, 3);
+  },
+
+  // Day of week: 0, 1, ..., 6
+  d(date: Date) {
+    return date.getDay();
+  },
+
+  // Day of week: Su, Mo, ...
+  dd(date: Date, dateLocale: TDateLocale) {
+    return this.dddd(date, dateLocale).slice(0, 2);
+  },
+
+  // Day of week: Sun, Mon, ...
+  ddd(date: Date, dateLocale: TDateLocale) {
+    return dateLocale.daysShort[date.getDay()];
+  },
+
+  // Day of week: Sunday, Monday, ...
+  dddd(date: Date, dateLocale: TDateLocale) {
+    return dateLocale.days[date.getDay()];
+  },
+
+  // Day of ISO week: 1, 2, ..., 7
+  E(date: Date) {
+    return date.getDay() || 7;
+  },
+
+  // Week of Year: 1 2 ... 52 53
+  w(date: Date) {
+    return getWeekOfYear(date);
+  },
+
+  // Week of Year: 01 02 ... 52 53
+  ww(date: Date) {
+    return pad(getWeekOfYear(date));
+  },
+
+  // Hour: 0, 1, ... 23
+  H(date: Date) {
+    return date.getHours();
+  },
+
+  // Hour: 00, 01, ..., 23
+  HH(date: Date) {
+    return pad(date.getHours());
+  },
+
+  // Hour: 1, 2, ..., 12
+  h(date: Date) {
+    const hours = date.getHours();
+    return hours === 0 ? 12 : hours > 12 ? hours % 12 : hours;
+  },
+
+  // Hour: 01, 02, ..., 12
+  hh(date: Date) {
+    return pad(this.h(date));
+  },
+
+  // Minute: 0, 1, ..., 59
+  m(date: Date) {
+    return date.getMinutes();
+  },
+
+  // Minute: 00, 01, ..., 59
+  mm(date: Date) {
+    return pad(date.getMinutes());
+  },
+
+  // Second: 0, 1, ..., 59
+  s(date: Date) {
+    return date.getSeconds();
+  },
+
+  // Second: 00, 01, ..., 59
+  ss(date: Date) {
+    return pad(date.getSeconds());
+  },
+
+  // 1/10 of second: 0, 1, ..., 9
+  S(date: Date) {
+    return Math.floor(date.getMilliseconds() / 100);
+  },
+
+  // 1/100 of second: 00, 01, ..., 99
+  SS(date: Date) {
+    return pad(Math.floor(date.getMilliseconds() / 10));
+  },
+
+  // Millisecond: 000, 001, ..., 999
+  SSS(date: Date) {
+    return pad(date.getMilliseconds(), 3);
+  },
+
+  // Meridiem: AM, PM
+  A(date: Date) {
+    return this.H(date) < 12 ? 'AM' : 'PM';
+  },
+
+  // Meridiem: am, pm
+  a(date: Date) {
+    return this.H(date) < 12 ? 'am' : 'pm';
+  },
+
+  // Meridiem: a.m., p.m.
+  aa(date: Date) {
+    return this.H(date) < 12 ? 'a.m.' : 'p.m.';
+  },
+
+  // Timezone: -01:00, +00:00, ... +12:00
+  Z(date: Date, _dateLocale: TDateLocale, _forcedYear: number, forcedTimezoneOffset: number) {
+    const tzOffset =
+      forcedTimezoneOffset === void 0 || forcedTimezoneOffset === null
+        ? date.getTimezoneOffset()
+        : forcedTimezoneOffset;
+
+    return formatTimezone(tzOffset, ':');
+  },
+
+  // Timezone: -0100, +0000, ... +1200
+  ZZ(date: Date, _dateLocale: TDateLocale, _forcedYear: number, forcedTimezoneOffset: number) {
+    const tzOffset =
+      forcedTimezoneOffset === void 0 || forcedTimezoneOffset === null
+        ? date.getTimezoneOffset()
+        : forcedTimezoneOffset;
+
+    return formatTimezone(tzOffset);
+  },
+
+  // Seconds timestamp: 512969520
+  X(date: Date) {
+    return Math.floor(date.getTime() / 1000);
+  },
+
+  // Milliseconds timestamp: 512969520900
+  x(date: Date) {
+    return date.getTime();
+  }
+};
+
+/**
+ * Format date by mask
+ * @param value
+ * @param mask
+ * @param dateLocale
+ * @param __forcedYear
+ * @param __forcedTimezoneOffset
+ */
+export function formatDate(
+  value: any,
+  mask: string,
+  dateLocale: TDateLocale,
+  __forcedYear: number,
+  __forcedTimezoneOffset: number
+): string | undefined {
+  if ((value !== 0 && !value) || value === Infinity || value === -Infinity) {
+    return;
+  }
+
+  const date = new Date(value) as unknown as number;
+
+  if (isNaN(date)) {
+    return;
+  }
+
+  if (mask === void 0) {
+    mask = defaultMask;
+  }
+
+  const locale = getDateLocale(dateLocale, defaultLang);
+
+  return mask.replace(token, (match, text) =>
+    match in formatter
+      ? formatter[match](date, locale, __forcedYear, __forcedTimezoneOffset)
+      : text === void 0
+      ? match
+      : text.split('\\]').join(']')
+  );
+}
+
+/**
+ * Set a specific year, month and day to a date.
+ * @param date
+ * @param rawModified
+ * @param utc
+ */
+export function adjustDate(date: Date, rawModified: IRawDate, utc: boolean) {
+  const modified = normalizeModified(rawModified);
+  const middle = utc ? 'UTC' : '';
+  const _date = new Date(date);
+  const adjustedDate =
+    modified.year || modified.month || modified.date ? applyYearMonthDay(_date, modified, middle) : _date;
+
+  for (const key in modified) {
+    const op = key.charAt(0).toUpperCase() + key.slice(1);
+    (adjustedDate as Date & Record<string, any>)[`set${middle}${op}`](modified[key]);
+  }
+
+  return adjustedDate;
+}
+
+/**
+ * Parse any string into a date object based on the format passed.
+ * @param str
+ * @param mask
+ * @param dateLocale
+ */
+export function extractDate(str: string, mask: string, dateLocale: TDateLocale) {
+  const sDate = splitDate(str, mask, dateLocale);
+
+  const date = new Date(
+    sDate.year as number,
+    (sDate.month ? sDate.month - 1 : null) as number,
+    sDate.day ? sDate.day : 1,
+    sDate.hour,
+    sDate.minute,
+    sDate.second,
+    sDate.millisecond
+  );
+
+  const tzOffset = date.getTimezoneOffset();
+
+  return !sDate.timezoneOffset || sDate.timezoneOffset === tzOffset
+    ? date
+    : getChange(date, { minutes: sDate.timezoneOffset - tzOffset }, 1);
+}
+
+/**
+ * Split date by mask.
+ * @param str
+ * @param mask
+ * @param dateLocale
+ * @param defaultModel
+ */
+export function splitDate(str: string, mask: string, dateLocale: TDateLocale, defaultModel?: IRawDate): IRawDate {
+  const date: IRawDate | Record<string, number | string | null> = {
+    year: null,
+    month: null,
+    day: null,
+    hour: null,
+    minute: null,
+    second: null,
+    millisecond: null,
+    timezoneOffset: null,
+    dateHash: null,
+    timeHash: null
+  };
+
+  defaultModel !== undefined && Object.assign(date, defaultModel);
+
+  if (str === undefined || str === null || str === '') return date;
+
+  if (!mask) mask = defaultMask;
+
+  const langOpts = getDateLocale(dateLocale, defaultLang);
+  const months = langOpts.months;
+  const monthsShort = langOpts.monthsShort;
+
+  const { regex, map } = getRegexData(mask, langOpts);
+  const match = str.match(regex);
+
+  if (match === null) return date;
+
+  let tzString = '';
+
+  if (map.X || map.x) {
+    const stamp = parseInt(match[map.X ? map.X : map.x], 10);
+
+    if (isNaN(stamp) || stamp < 0) return date;
+
+    const _date = new Date(stamp * (map.X ? 1000 : 0));
+
+    date.year = _date.getFullYear();
+    date.month = _date.getMonth() + 1;
+    date.date = _date.getDate();
+    date.hour = _date.getHours();
+    date.minute = _date.getMinutes();
+    date.second = _date.getSeconds();
+    date.millisecond = _date.getMilliseconds();
+  } else {
+    if (map.YYYY) {
+      date.year = parseInt(match[map.YYYY], 10);
+    } else if (map.YY) {
+      const year = parseInt(match[map.YY], 10);
+      date.year = year < 0 ? year : 2000 + year;
+    }
+
+    if (map.M) {
+      date.month = parseInt(match[map.M], 10);
+      if (date.month < 1 || date.month > 12) return date;
+    } else if (map.MMM) {
+      date.month = monthsShort.indexOf(match[map.MMM]) + 1;
+    } else if (map.MMMM) {
+      date.month = months.indexOf(match[map.MMMM]) + 1;
+    }
+
+    if (map.D) {
+      date.day = parseInt(match[map.D], 10);
+      if (date.year === null || date.month === null || date.day < 1) return date;
+
+      const maxDay = new Date(date.year as number, date.month as number, 0).getDate();
+      if (date.day > maxDay) return date;
+    }
+
+    if (map.H) {
+      date.hour = parseInt(match[map.H], 10) % 24;
+    } else if (map.h) {
+      date.hour = parseInt(match[map.h], 10) % 12;
+
+      if (
+        (map.A && match[map.A] === 'PM') ||
+        (map.a && match[map.a] === 'pm') ||
+        (map.aa && match[map.aa] === 'p.m.')
+      ) {
+        date.hour += 12;
+      }
+
+      date.hour = date.hour % 24;
+    }
+
+    if (map.m) {
+      date.minute = parseInt(match[map.m], 10) % 60;
+    }
+
+    if (map.s) {
+      date.second = parseInt(match[map.s], 10) % 60;
+    }
+
+    if (map.S) {
+      date.millisecond = parseInt(match[map.S], 10) * 10 ** (3 - match[map.S].length);
+    }
+
+    if (map.Z || map.ZZ) {
+      tzString = map.Z ? match[map.Z].replace(':', '') : match[map.ZZ];
+      date.timezoneOffset = (tzString[0] === '+' ? -1 : 1) * (60 * +tzString.slice(1, 3) + +tzString.slice(3, 5));
+    }
+  }
+
+  date.dateHash = pad(date.year as number, 6) + '/' + pad(date.month as number) + '/' + pad(date.day as number);
+  date.timeHash =
+    pad(date.hour as number) + ':' + pad(date.minute as number) + ':' + pad(date.second as number) + tzString;
+
+  return date;
+}
+
+/**
+ * Check a date string for validity.
+ * @param date
+ */
+export function isValid(date: any): boolean {
+  return typeof date === 'number' ? true : !isNaN(Date.parse(date));
+}
+
+/**
+ * The following method is just a wrapper to help you in cases where you just need current time but with a different year, or month, or second etc.
+ * @param modified
+ * @param utc
+ */
+export function buildDate(modified: IRawDate, utc: boolean) {
+  return adjustDate(new Date(), modified, utc);
+}
+
+/**
+ * Get the day number in week for a given date.
+ * @param date
+ */
+export function getDayOfWeek(date: Date): number {
+  const dow = new Date(date).getDay();
+  return dow === 0 ? 7 : dow;
+}
+
+/**
+ * Get the week number in year for a given date.
+ * @param date
+ */
+export function getWeekOfYear(date: Date): number {
+  const thursday = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  thursday.setDate(thursday.getDate() - ((thursday.getDay() + 6) % 7) + 3);
+
+  const firstThursday = new Date(thursday.getFullYear(), 0, 4);
+  firstThursday.setDate(firstThursday.getDate() - ((firstThursday.getDay() + 6) % 7) + 3);
+
+  const ds = thursday.getTimezoneOffset() - firstThursday.getTimezoneOffset();
+  thursday.setHours(thursday.getHours() - ds);
+
+  const weekDiff = (+thursday - +firstThursday) / (MILLISECONDS_IN_DAY * 7);
+  return 1 + Math.floor(weekDiff);
+}
+
+/**
+ * Get the day of the year from a given date.
+ * @param date
+ */
+export function getDayOfYear(date: Date): number | undefined {
+  const dayOfYear = getDateDiff(date, startOfDate(date, 'year'), 'days');
+  return dayOfYear ? dayOfYear + 1 : undefined;
+}
+
+/**
+ * Check a date is in a given date/time range.
+ * @param date
+ * @param from
+ * @param to
+ * @param opts
+ */
+export function isBetweenDates(
+  date: Date,
+  from: Date,
+  to: Date,
+  opts: { onlyDate: boolean; inclusiveFrom: boolean; inclusiveTo: boolean }
+): boolean {
+  const date1 = getDateIdentifier(from, opts.onlyDate);
+  const date2 = getDateIdentifier(to, opts.onlyDate);
+  const current = getDateIdentifier(date, opts.onlyDate);
+
+  return (
+    (current > date1 || (opts.inclusiveFrom && current === date1)) &&
+    (current < date2 || (opts.inclusiveTo && current === date2))
+  );
+}
+
+/**
+ * Add a given date/time unit from a given date.
+ * @param date
+ * @param modified
+ */
+export function addToDate(date: Date, modified: IRawDate): Date {
+  return getChange(date, modified, 1);
+}
+
+/**
+ * Subtract a given date/time unit from a given date.
+ * @param date
+ * @param modified
+ */
+export function subtractFromDate(date: Date, modified: IRawDate): Date {
+  return getChange(date, modified, -1);
+}
+
+/**
+ * Beginning of a given date/time unit for a given date.
+ * @param date
+ * @param unit
+ * @param utc
+ */
+export function startOfDate(date: Date, unit: string, utc?: boolean): Date {
+  const _date = new Date(date);
+  const prefix = `set${utc ? 'UTC' : ''}`;
+
+  switch (unit) {
+    case 'year':
+    case 'years':
+      (_date as Date & Record<string, any>)[`${prefix}Month`](0);
+    // eslint-disable-next-line no-fallthrough
+    case 'month':
+    case 'months':
+      (_date as Date & Record<string, any>)[`${prefix}Date`](1);
+    // eslint-disable-next-line no-fallthrough
+    case 'day':
+    case 'days':
+    case 'date':
+      (_date as Date & Record<string, any>)[`${prefix}Hours`](0);
+    // eslint-disable-next-line no-fallthrough
+    case 'hour':
+    case 'hours':
+      (_date as Date & Record<string, any>)[`${prefix}Minutes`](0);
+    // eslint-disable-next-line no-fallthrough
+    case 'minute':
+    case 'minutes':
+      (_date as Date & Record<string, any>)[`${prefix}Seconds`](0);
+    // eslint-disable-next-line no-fallthrough
+    case 'second':
+    case 'seconds':
+      (_date as Date & Record<string, any>)[`${prefix}Milliseconds`](0);
+  }
+
+  return _date;
+}
+
+/**
+ * End of a given date/time unit for a given date.
+ * @param date
+ * @param unit
+ * @param utc
+ */
+export function endOfDate(date: Date, unit: string, utc: boolean): Date {
+  const _date = new Date(date),
+    prefix = `set${utc ? 'UTC' : ''}`;
+
+  switch (unit) {
+    case 'year':
+    case 'years':
+      (_date as Date & Record<string, any>)[`${prefix}Month`](11);
+    // eslint-disable-next-line no-fallthrough
+    case 'month':
+    case 'months':
+      (_date as Date & Record<string, any>)[`${prefix}Date`](daysInMonth(_date));
+    // eslint-disable-next-line no-fallthrough
+    case 'day':
+    case 'days':
+    case 'date':
+      (_date as Date & Record<string, any>)[`${prefix}Hours`](23);
+    // eslint-disable-next-line no-fallthrough
+    case 'hour':
+    case 'hours':
+      (_date as Date & Record<string, any>)[`${prefix}Minutes`](59);
+    // eslint-disable-next-line no-fallthrough
+    case 'minute':
+    case 'minutes':
+      (_date as Date & Record<string, any>)[`${prefix}Seconds`](59);
+    // eslint-disable-next-line no-fallthrough
+    case 'second':
+    case 'seconds':
+      (_date as Date & Record<string, any>)[`${prefix}Milliseconds`](999);
+  }
+  return _date;
+}
+
+/**
+ * Get the maximum date from a given date and other dates.
+ * @param date
+ * @param args
+ */
+export function getMaxDate(date: Date, ...args: Date[]): Date {
+  let _date = new Date(date) as unknown as number;
+  Array.prototype.slice.call(args, 1).forEach((date) => {
+    _date = Math.max(_date, new Date(date) as unknown as number);
+  });
+  return _date as unknown as Date;
+}
+
+/**
+ * Get the minimum date from a given date and other dates.
+ * @param date
+ * @param args
+ */
+export function getMinDate(date: Date, ...args: Date[]): Date {
+  let _date = new Date(date) as unknown as number;
+  Array.prototype.slice.call(args, 1).forEach((date) => {
+    _date = Math.min(_date, new Date(date) as unknown as number);
+  });
+  return _date as unknown as Date;
+}
+
+/**
+ * Get the difference between two dates.
+ * @param date
+ * @param subtract
+ * @param unit
+ */
+export function getDateDiff(date: Date, subtract: Date, unit = 'days'): number {
+  const date1 = new Date(date);
+  const date2 = new Date(subtract);
+
+  switch (unit) {
+    case 'years':
+    case 'year':
+      return date1.getFullYear() - date2.getFullYear();
+
+    case 'months':
+    case 'month':
+      return (date1.getFullYear() - date2.getFullYear()) * 12 + date1.getMonth() - date2.getMonth();
+
+    case 'days':
+    case 'day':
+    case 'date':
+      return getDiff(startOfDate(date1, 'day'), startOfDate(date2, 'day'), MILLISECONDS_IN_DAY);
+
+    case 'hours':
+    case 'hour':
+      return getDiff(startOfDate(date1, 'hour'), startOfDate(date2, 'hour'), MILLISECONDS_IN_HOUR);
+
+    case 'minutes':
+    case 'minute':
+      return getDiff(startOfDate(date1, 'minute'), startOfDate(date2, 'minute'), MILLISECONDS_IN_MINUTE);
+
+    case 'seconds':
+    case 'second':
+      return getDiff(startOfDate(date1, 'second'), startOfDate(date2, 'second'), 1000);
+
+    default:
+      return 0;
+  }
+}
+
+/**
+ * Get date format
+ * @param date
+ */
+export function inferDateFormat(date: Date | any): 'date' | 'number' | 'string' {
+  return isDate(date) ? 'date' : typeof date === 'number' ? 'number' : 'string';
+}
+
+/**
+ * Normalize a date in a given date/time range.
+ * @param date
+ * @param min
+ * @param max
+ */
+export function getDateBetween(date: Date, min: Date, max: Date): Date {
+  const t = new Date(date);
+
+  if (min) {
+    const low = new Date(min);
+    if (t < low) {
+      return low;
+    }
+  }
+
+  if (max) {
+    const high = new Date(max);
+    if (t > high) {
+      return high;
+    }
+  }
+
+  return t;
+}
+
+/**
+ * Check of two dates unit are equal.
+ * @param date1
+ * @param date2
+ * @param unit
+ */
+export function isSameDate(date1: Date, date2: Date, unit: string): boolean {
+  const _date1 = new Date(date1);
+  const _date2 = new Date(date2);
+
+  if (unit === void 0) {
+    return _date1.getTime() === _date2.getTime();
+  }
+
+  switch (unit) {
+    case 'second':
+    case 'seconds':
+      if (_date1.getSeconds() !== _date2.getSeconds()) {
+        return false;
+      }
+    // eslint-disable-next-line no-fallthrough
+    case 'minute':
+    case 'minutes':
+      if (_date1.getMinutes() !== _date2.getMinutes()) {
+        return false;
+      }
+    // eslint-disable-next-line no-fallthrough
+    case 'hour':
+    case 'hours':
+      if (_date1.getHours() !== _date2.getHours()) {
+        return false;
+      }
+    // eslint-disable-next-line no-fallthrough
+    case 'day':
+    case 'days':
+    case 'date':
+      if (_date1.getDate() !== _date2.getDate()) {
+        return false;
+      }
+    // eslint-disable-next-line no-fallthrough
+    case 'month':
+    case 'months':
+      if (_date1.getMonth() !== _date2.getMonth()) {
+        return false;
+      }
+    // eslint-disable-next-line no-fallthrough
+    case 'year':
+    case 'years':
+      if (_date1.getFullYear() !== _date2.getFullYear()) {
+        return false;
+      }
+      break;
+    default:
+      throw new Error(`date isSameDate unknown unit ${unit}`);
+  }
+
+  return true;
+}
+
+/**
+ * Get the number of days in a month.
+ * @param date
+ */
+export function daysInMonth(date: Date): number {
+  return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate();
+}
+
+/**
+ * Cloning date object.
+ * @param date
+ */
+export function clone(date: Date): Date {
+  return isDate(date) ? new Date(date.getTime()) : date;
+}
+
+function getRegexData(mask: string, dateLocale: TDateLocale): { map: Record<string, any>; regex: RegExp } {
+  const days = '(' + dateLocale.days.join('|') + ')';
+  const key = mask + days;
+
+  if (regexStore[key]) return regexStore[key];
+
+  const daysShort = '(' + dateLocale.daysShort.join('|') + ')';
+  const months = '(' + dateLocale.months.join('|') + ')';
+  const monthsShort = '(' + dateLocale.monthsShort.join('|') + ')';
+
+  const map: Record<string, any> = {};
+  let index = 0;
+
+  const regexText = mask.replace(reverseToken, (match) => {
+    index++;
+    switch (match) {
+      case 'YY':
+        map.YY = index;
+        return '(-?\\d{1,2})';
+      case 'YYYY':
+        map.YYYY = index;
+        return '(-?\\d{1,4})';
+      case 'M':
+        map.M = index;
+        return '(\\d{1,2})';
+      case 'MM':
+        map.M = index; // bumping to M
+        return '(\\d{2})';
+      case 'MMM':
+        map.MMM = index;
+        return monthsShort;
+      case 'MMMM':
+        map.MMMM = index;
+        return months;
+      case 'D':
+        map.D = index;
+        return '(\\d{1,2})';
+      case 'Do':
+        map.D = index++; // bumping to D
+        return '(\\d{1,2}(st|nd|rd|th))';
+      case 'DD':
+        map.D = index; // bumping to D
+        return '(\\d{2})';
+      case 'H':
+        map.H = index;
+        return '(\\d{1,2})';
+      case 'HH':
+        map.H = index; // bumping to H
+        return '(\\d{2})';
+      case 'h':
+        map.h = index;
+        return '(\\d{1,2})';
+      case 'hh':
+        map.h = index; // bumping to h
+        return '(\\d{2})';
+      case 'm':
+        map.m = index;
+        return '(\\d{1,2})';
+      case 'mm':
+        map.m = index; // bumping to m
+        return '(\\d{2})';
+      case 's':
+        map.s = index;
+        return '(\\d{1,2})';
+      case 'ss':
+        map.s = index; // bumping to s
+        return '(\\d{2})';
+      case 'S':
+        map.S = index;
+        return '(\\d{1})';
+      case 'SS':
+        map.S = index; // bump to S
+        return '(\\d{2})';
+      case 'SSS':
+        map.S = index; // bump to S
+        return '(\\d{3})';
+      case 'A':
+        map.A = index;
+        return '(AM|PM)';
+      case 'a':
+        map.a = index;
+        return '(am|pm)';
+      case 'aa':
+        map.aa = index;
+        return '(a\\.m\\.|p\\.m\\.)';
+
+      case 'ddd':
+        return daysShort;
+      case 'dddd':
+        return days;
+      case 'Q':
+      case 'd':
+      case 'E':
+        return '(\\d{1})';
+      case 'Qo':
+        return '(1st|2nd|3rd|4th)';
+      case 'DDD':
+      case 'DDDD':
+        return '(\\d{1,3})';
+      case 'w':
+        return '(\\d{1,2})';
+      case 'ww':
+        return '(\\d{2})';
+
+      case 'Z': // to split: (?:(Z)()()|([+-])?(\\d{2}):?(\\d{2}))
+        map.Z = index;
+        return '(Z|[+-]\\d{2}:\\d{2})';
+      case 'ZZ':
+        map.ZZ = index;
+        return '(Z|[+-]\\d{2}\\d{2})';
+
+      case 'X':
+        map.X = index;
+        return '(-?\\d+)';
+      case 'x':
+        map.x = index;
+        return '(-?\\d{4,})';
+
+      default:
+        index--;
+        if (match[0] === '[') {
+          match = match.substring(1, match.length - 1);
+        }
+        return match.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+  });
+
+  const result = { map, regex: new RegExp('^' + regexText) };
+  regexStore[key] = result;
+
+  return result;
+}
+
+function getDateLocale(paramDateLocale: TDateLocale, locale: ILocale): TDateLocale {
+  return paramDateLocale ? paramDateLocale : locale ? locale.date : defaultLang.date;
+}
+
+function formatTimezone(offset: number, delimiter: string = ''): string {
+  const sign = offset > 0 ? '-' : '+';
+  const absOffset = Math.abs(offset);
+  const hours = Math.floor(absOffset / 60);
+  const minutes = absOffset % 60;
+
+  return sign + pad(hours) + delimiter + pad(minutes);
+}
+
+function applyYearMonthDayChange(date: Date, modified: IRawDate, sign: number): Date {
+  let year = date.getFullYear();
+  let month = date.getMonth();
+  const day = date.getMonth();
+
+  if (modified.year) {
+    year += sign * modified.year;
+    delete modified.year;
+  }
+
+  if (modified.month) {
+    month += sign * modified.month;
+    delete modified.month;
+  }
+
+  date.setDate(1);
+  date.setMonth(2);
+  date.setFullYear(year);
+  date.setMonth(month);
+  date.setDate(Math.min(day, daysInMonth(date)));
+
+  if (modified.date) {
+    date.setDate(date.getDate() + sign * modified.date);
+    delete modified.date;
+  }
+
+  return date;
+}
+
+function applyYearMonthDay(date: Date, modified: IRawDate, middle: string): Date {
+  const year = modified.year ? modified.year : (date as any)[`get${middle}FullYear`]();
+  const month = modified.month ? modified.month - 1 : (date as any)[`get${middle}Month`]();
+  const maxDay = new Date(year, month + 1, 0).getDate();
+  const day = Math.min(maxDay, modified.date ? modified.date : (date as any)[`get${middle}Date`]());
+
+  (date as Date & Record<string, any>)[`set${middle}Date`](1);
+  (date as Date & Record<string, any>)[`set${middle}Month`](2);
+  (date as Date & Record<string, any>)[`set${middle}FullYear`](year);
+  (date as Date & Record<string, any>)[`set${middle}Month`](month);
+  (date as Date & Record<string, any>)[`set${middle}Date`](day);
+
+  delete modified.year;
+  delete modified.month;
+  delete modified.date;
+
+  return date;
+}
+
+function getChange(date: Date, rawModified: IRawDate & Record<string, any>, sign: number): Date {
+  const modified = normalizeModified(rawModified);
+  const _date = new Date(date);
+  const changedDate =
+    modified.year || modified.month || modified.date ? applyYearMonthDayChange(date, modified, sign) : _date;
+
+  for (const key in modified) {
+    const op = key.charAt(0).toUpperCase() + key.slice(1);
+    (changedDate as Date & Record<string, any>)[`set${op}`]((changedDate as Date & Record<string, any>)[`get${op}`])() +
+      sign * modified[key];
+  }
+
+  return changedDate;
+}
+
+function normalizeModified(modified: IRawDate & Record<string, any>) {
+  const acc = { ...modified };
+
+  if (modified.years) {
+    acc.year = modified.years;
+    delete acc.years;
+  }
+
+  if (modified.months) {
+    acc.month = modified.months;
+    delete acc.months;
+  }
+
+  if (modified.days) {
+    acc.date = modified.days;
+    delete acc.days;
+  }
+  if (modified.day) {
+    acc.date = modified.day;
+    delete acc.day;
+  }
+
+  if (modified.hour) {
+    acc.hours = modified.hour;
+    delete acc.hour;
+  }
+
+  if (modified.minute) {
+    acc.minutes = modified.minute;
+    delete acc.minute;
+  }
+
+  if (modified.second) {
+    acc.seconds = modified.second;
+    delete acc.second;
+  }
+
+  if (modified.millisecond) {
+    acc.milliseconds = modified.millisecond;
+    delete acc.millisecond;
+  }
+
+  return acc;
+}
+
+function getDayIdentifier(date: Date): number {
+  return date.getFullYear() * 10000 + date.getMonth() * 100 + date.getDate();
+}
+
+function getDateIdentifier(date: Date, onlyDate?: boolean): number {
+  const _date = new Date(date);
+  return onlyDate ? getDayIdentifier(_date) : _date.getTime();
+}
+
+function getDiff(date1: Date, date2: Date, interval: number): number {
+  return (
+    (date1.getTime() -
+      date1.getTimezoneOffset() * MILLISECONDS_IN_MINUTE -
+      (date2.getTime() - date2.getTimezoneOffset() * MILLISECONDS_IN_MINUTE)) /
+    interval
+  );
+}
+
+function getOrdinal(n: number) {
+  if (n >= 11 && n <= 13) {
+    return `${n}th`;
+  }
+  switch (n % 10) {
+    case 1:
+      return `${n}st`;
+    case 2:
+      return `${n}nd`;
+    case 3:
+      return `${n}rd`;
+  }
+  return `${n}th`;
+}
+
+export default {
+  formatDate,
+  clone,
+  isValid,
+  buildDate,
+  getDayOfWeek,
+  getWeekOfYear,
+  isBetweenDates,
+  addToDate,
+  subtractFromDate,
+  adjustDate,
+  startOfDate,
+  endOfDate,
+  getMaxDate,
+  getMinDate,
+  getDateDiff,
+  getDayOfYear,
+  inferDateFormat,
+  getDateBetween,
+  isSameDate,
+  daysInMonth
+};