@zohodesk/i18n 1.0.0-beta.3 → 1.0.0-beta.30

package/es/utils/index.js

@@ -0,0 +1,592 @@
+import datetime from '@zohodesk/datetimejs';
+import { i18NProviderUtils } from '../components/I18NProvider';
+export const dayi18n = {
+  'Sun': 'deskreact.calendar.daynameshort.sunday',
+  'Mon': 'deskreact.calendar.daynameshort.monday',
+  'Tue': 'deskreact.calendar.daynameshort.tuesday',
+  'Wed': 'deskreact.calendar.daynameshort.wednesday',
+  'Thu': 'deskreact.calendar.daynameshort.thursday',
+  'Fri': 'deskreact.calendar.daynameshort.friday',
+  'Sat': 'deskreact.calendar.daynameshort.saturday',
+  'Sunday': 'deskreact.calendar.dayname.sunday',
+  'Monday': 'deskreact.calendar.dayname.monday',
+  'Tuesday': 'deskreact.calendar.dayname.tuesday',
+  'Wednesday': 'deskreact.calendar.dayname.wednesday',
+  'Thursday': 'deskreact.calendar.dayname.thursday',
+  'Friday': 'deskreact.calendar.dayname.friday',
+  'Saturday': 'deskreact.calendar.dayname.saturday'
+};
+export const monthi18n = {
+  'Jan': 'deskreact.calendar.monthnameshort.january',
+  'Feb': 'deskreact.calendar.monthnameshort.february',
+  'Mar': 'deskreact.calendar.monthnameshort.march',
+  'Apr': 'deskreact.calendar.monthnameshort.april',
+  'May': 'deskreact.calendar.monthnameshort.may',
+  'Jun': 'deskreact.calendar.monthnameshort.june',
+  'Jul': 'deskreact.calendar.monthnameshort.july',
+  'Aug': 'deskreact.calendar.monthnameshort.august',
+  'Sep': 'deskreact.calendar.monthnameshort.september',
+  'Oct': 'deskreact.calendar.monthnameshort.october',
+  'Nov': 'deskreact.calendar.monthnameshort.november',
+  'Dec': 'deskreact.calendar.monthnameshort.december',
+  'January': 'deskreact.calendar.monthname.january',
+  'February': 'deskreact.calendar.monthname.february',
+  'March': 'deskreact.calendar.monthname.march',
+  'April': 'deskreact.calendar.monthname.april',
+  'May': 'deskreact.calendar.monthname.may',
+  'June': 'deskreact.calendar.monthname.june',
+  'July': 'deskreact.calendar.monthname.july',
+  'August': 'deskreact.calendar.monthname.august',
+  'September': 'deskreact.calendar.monthname.september',
+  'October': 'deskreact.calendar.monthname.october',
+  'November': 'deskreact.calendar.monthname.november',
+  'December': 'deskreact.calendar.monthname.december'
+};
+export const timei18n = {
+  'a': 'support.time.format.time.am.short.small',
+  'p': 'support.time.format.time.pm.short.small',
+  'am': 'support.time.format.time.am.small',
+  'pm': 'support.time.format.time.pm.small',
+  'A': 'support.time.format.time.am.short',
+  'P': 'support.time.format.time.pm.short',
+  'AM': 'deskreact.calendar.ampmtext.am',
+  'PM': 'deskreact.calendar.ampmtext.pm'
+};
+let dateFormat = {
+  dayNames: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
+  monthNames: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
+  timeNames: ['a', 'p', 'am', 'pm', 'A', 'P', 'AM', 'PM']
+};
+export function formatDate(dateMill, mask, dateDiffObj) {
+  if (mask === 'facebookFormat') {
+    let {
+      hours,
+      minutes,
+      seconds,
+      yDays,
+      years,
+      betweenleepYears,
+      crntMonth
+    } = dateDiffObj;
+
+    if (years > 0) {
+      return `${years}y`;
+    } else if (yDays > 0) {
+      let isFeb = crntMonth === 1;
+      let isThoneMonth = [0, 2, 4, 6, 7, 9, 11].indexOf(crntMonth) != -1;
+
+      let weekCal = function (calDays) {
+        let weeks = calDays / 7;
+        return weeks < 1 ? `${calDays}d` : `${Math.trunc(weeks)}w`;
+      };
+
+      if (!isFeb) {
+        return isThoneMonth === true ? yDays === 31 ? '1m' : weekCal(yDays) : yDays === 30 ? '1m' : weekCal(yDays);
+      }
+
+      if (betweenleepYears != 0) {
+        return isFeb === true && yDays === 28 ? '1m' : weekCal(yDays);
+      }
+
+      return isFeb === true && yDays === 29 ? '1m' : weekCal(yDays);
+    } else if (hours < 24 && hours > 0) {
+      return `${hours}h`;
+    } else if (minutes < 60 && hours > 1) {
+      return `${minutes}m`;
+    }
+
+    return seconds === 0 ? 'now' : `${seconds}s`;
+  }
+
+  let date = new Date(dateMill);
+  let d = date.getDate();
+  let D = date.getDay();
+  let m = date.getMonth();
+  let y = date.getFullYear();
+  let H = date.getHours();
+  let M = date.getMinutes();
+  let s = date.getSeconds();
+  let L = date.getMilliseconds();
+  let flags = {
+    d: d,
+    dd: pad(d, 2),
+    ddd: i18NProviderUtils.getI18NValue(dayi18n[dateFormat.dayNames[D]]),
+    dddd: i18NProviderUtils.getI18NValue(dayi18n[dateFormat.dayNames[D + 7]]),
+    D: d,
+    DD: pad(d, 2),
+    DDD: i18NProviderUtils.getI18NValue(dayi18n[dateFormat.dayNames[D]]),
+    DDDD: i18NProviderUtils.getI18NValue(dayi18n[dateFormat.dayNames[D + 7]]),
+    M: m + 1,
+    MM: pad(m + 1, 2),
+    MMM: i18NProviderUtils.getI18NValue(monthi18n[dateFormat.monthNames[m]]),
+    MMMM: i18NProviderUtils.getI18NValue(monthi18n[dateFormat.monthNames[m + 12]]),
+    yy: String(y).slice(2),
+    YY: String(y).slice(2),
+    yyyy: y,
+    YYYY: y,
+    h: H % 12 || 12,
+    hh: pad(H % 12 || 12, 2),
+    H: H,
+    HH: pad(H, 2),
+    m: M,
+    mm: pad(M, 2),
+    s: s,
+    ss: pad(s, 2),
+    l: pad(L, 3),
+    L: pad(Math.round(L / 10)),
+    t: H < 12 ? i18NProviderUtils.getI18NValue(timei18n[dateFormat.timeNames[0]]) : i18NProviderUtils.getI18NValue(timei18n[dateFormat.timeNames[1]]),
+    A: H < 12 ? i18NProviderUtils.getI18NValue(timei18n[dateFormat.timeNames[6]]) : i18NProviderUtils.getI18NValue(timei18n[dateFormat.timeNames[7]]),
+    T: H < 12 ? i18NProviderUtils.getI18NValue(timei18n[dateFormat.timeNames[4]]) : i18NProviderUtils.getI18NValue(timei18n[dateFormat.timeNames[5]])
+  };
+  let token = /D{1,4}|M{1,4}|YY(?:YY)?|([HhmsA])\1?|[LloSZWN]|\[[^\]]*\]|'[^']*'/gi;
+  let dat = mask.replace(token, match => {
+    if (match in flags) {
+      return flags[match];
+    }
+
+    return match.slice(1, match.length - 1);
+  });
+  return dat;
+}
+export function pad(n) {
+  let width = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  let z = arguments.length > 2 ? arguments[2] : undefined;
+  z = z || '0';
+  n = `${n}`;
+  return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
+}
+export function replaceI18NValuesWithRegex(i18nStr, values) {
+  if (typeof values !== 'undefined') {
+    if (Array.isArray(values)) {
+      for (let i = 0; i < values.length; i++) {
+        i18nStr = i18nStr.replace(new RegExp(`\\{${i}\\}`, 'g'), values[i]);
+      }
+    } else {
+      i18nStr = i18nStr.replace(new RegExp('\\{0\\}', 'g'), values);
+    }
+  }
+
+  return i18nStr;
+}
+export function unescapeUnicode(str) {
+  return str.replace(/\\u([a-fA-F0-9]{4})/g, (g, m1) => String.fromCharCode(parseInt(m1, 16)));
+}
+export function getValues() {
+  let params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let diff = arguments.length > 1 ? arguments[1] : undefined;
+  return params.map(param => diff[param]);
+}
+export function isObject(item) {
+  return item && typeof item === 'object' && !Array.isArray(item);
+}
+let localizedData = {};
+let localizedStringData = {};
+
+let getMappedKey = key => key;
+
+function setLocalizedStringData(data) {
+  let keyString = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+
+  if (typeof data === 'string') {
+    localizedStringData[keyString] = data;
+    return;
+  }
+
+  const keys = Object.keys(data);
+
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const newKeyString = keyString ? `${keyString}.${key}` : key;
+    setLocalizedStringData(data[key], newKeyString);
+  }
+}
+
+export function setLocalizedData(data) {
+  const translationData = isObject(data) ? data : {};
+  localizedData = translationData;
+  setLocalizedStringData(translationData);
+}
+export function setI18NKeyMapping(func) {
+  getMappedKey = func;
+}
+export function getLocalizedValue() {
+  let {
+    type,
+    moduleName,
+    deptName,
+    folderName,
+    reportId,
+    reportName,
+    apiName,
+    fieldValue,
+    layoutName
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let localizedValue = localizedData;
+
+  switch (type) {
+    case 'field':
+      ['Field', moduleName, apiName].map(key => {
+        localizedValue = localizedValue[key] || '';
+      });
+      break;
+
+    case 'picklist':
+      ['PickListValue', moduleName, apiName, fieldValue].map(key => {
+        localizedValue = localizedValue[key] || '';
+      });
+      break;
+
+    case 'layout':
+      if (deptName != null) {
+        ['Layout', moduleName, deptName, layoutName].map(() => {
+          localizedValue = localizedValue[key] || '';
+        });
+      } else {
+        ['Layout', moduleName, layoutName].map(() => {
+          localizedValue = localizedValue[key] || '';
+        });
+      }
+
+      break;
+
+    case 'report':
+      ['Report', deptName, folderName, reportName, reportId].map(key => {
+        localizedValue = localizedValue[key] || '';
+      });
+
+    default:
+      return null;
+  }
+
+  return localizedValue || null;
+}
+export function getI18NValue(i18n) {
+  if (typeof i18n === 'undefined') {
+    return key => key;
+  }
+
+  return (key, values, localizedProps) => {
+    const localizedValue = localizedProps ? getLocalizedValue(localizedProps) : localizedStringData[key];
+    const finalKey = getMappedKey(key);
+    let i18nStr = i18n[finalKey];
+
+    if (i18nStr === undefined) {
+      return localizedValue || finalKey;
+    }
+
+    i18nStr = replaceI18NValuesWithRegex(i18nStr, values);
+    return localizedValue || unescapeUnicode(i18nStr);
+  };
+} // function getValues(params = [], diff) {
+//   return params.map(param => {
+//     return diff[param];
+//   });
+// }
+
+export function getI18NInfo(toDateObj, props, diffObj) {
+  let key = null,
+      values,
+      text = null;
+
+  if (typeof props === 'function') {
+    let value = props(diffObj1);
+    key = value.key;
+    values = getValues(value.params, diffObj);
+  } else if (typeof props === 'object') {
+    key = props.key;
+    values = getValues(props.params, diffObj);
+  } else if (typeof props === 'string') {
+    text = toDateObj.format(props);
+  }
+
+  return {
+    key,
+    values,
+    text
+  };
+}
+export function isToday(fromDate, toDate) {
+  let TODAY = toDate.clone().startOf('day');
+  return fromDate.isSame(TODAY, 'd');
+}
+export function isYesterday(fromDate, toDate) {
+  let YESTERDAY = toDate.clone().subtract(1, 'days').startOf('day');
+  return fromDate.isSame(YESTERDAY, 'd');
+}
+export function isTomorrow(fromDate, toDate) {
+  return isYesterday(toDate, fromDate);
+}
+export function isWithinAWeek(fromDate, toDate) {
+  let A_WEEK_OLD = toDate.clone().subtract(7, 'days').startOf('day');
+  return fromDate.isAfter(A_WEEK_OLD);
+}
+export function isTwoWeeksOrMore(fromDate, toDate) {
+  return !isWithinAWeek(fromDate, toDate);
+}
+export function getDatePatternWithoutYear(datePattern) {
+  let dateObj;
+  let delemiter;
+
+  if (datePattern.indexOf('.') !== -1) {
+    dateObj = datePattern.split('.');
+    delemiter = '.';
+  } else if (datePattern.indexOf('-') !== -1) {
+    dateObj = datePattern.split('-');
+    delemiter = '-';
+  } else if (datePattern.indexOf('/') !== -1) {
+    dateObj = datePattern.split('/');
+    delemiter = '/';
+  } else {
+    dateObj = datePattern.split(' ');
+    delemiter = ' ';
+  }
+
+  return dateObj.filter(data => ['yy', 'yyyy'].indexOf(data) === -1).join(delemiter);
+}
+export function userDateFormat(getI18NValue, timezoneData, timeFormat, datePattern, isEnabledCurrentYear) {
+  return function (to, _ref, ago, later) {
+    let {
+      today,
+      yesterday,
+      tomorrow,
+      others
+    } = _ref;
+    let isSuffixEnable = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+    let format = arguments.length > 5 ? arguments[5] : undefined;
+    let fromDateObj = datetime.toDate(datetime.tz.utcToTz(null, timezoneData));
+    let toDateObj = datetime.toDate(datetime.tz.utcToTz(to, timezoneData));
+    let diffMin = new Date(to).getTime() - new Date().getTime();
+    let from = new Date();
+    from = from.toISOString();
+    let suffix;
+
+    if (diffMin < 0) {
+      suffix = ago || '';
+    } else if (diffMin > 0) {
+      suffix = later || '';
+    } else {
+      suffix = '';
+    }
+
+    let diff = getDiffObj(diffMin);
+    let withInAWeak = diff.y === 0 && diff.yd <= 7;
+    let diffObj = {
+      h: diff.h,
+      m: diff.m,
+      s: diff.s,
+      y: diff.y,
+      hh: pad(diff.h, 2),
+      mm: pad(diff.m, 2),
+      ss: pad(diff.s, 2),
+      yy: pad(diff.y, 2),
+      days: diff.yd,
+      yDays: pad(diff.yd, 2),
+      isWithInAWeek: withInAWeak,
+      suffix: suffix
+    };
+    let diffObj1 = {
+      hours: diff.h,
+      minutes: diff.m,
+      seconds: diff.s,
+      years: diff.y,
+      yDays: diff.yd,
+      crntYear: new Date(from).getFullYear(),
+      tYear: new Date(to).getFullYear(),
+      isWithInAWeek: withInAWeak,
+      suffix: suffix,
+      timeFormat: timeFormat,
+      datePattern: datePattern,
+      dateTimePattern: `${datePattern} ${timeFormat}`
+    }; //In if condition we'll remove year and set date format  if the current year is not required
+    //In else part we'll set the date format as it is
+
+    if (isEnabledCurrentYear === true && diffObj1.years === 0 && diffObj1.tYear === diffObj1.crntYear) {
+      let dateFormat = getDatePatternWithoutYear(datePattern);
+      diffObj1.dateFormat = dateFormat;
+      diffObj1.dateTimeFormat = `${dateFormat} ${timeFormat}`;
+    } else {
+      diffObj1.dateFormat = datePattern;
+      diffObj1.dateTimeFormat = `${datePattern} ${timeFormat}`;
+    } //var daysDiff = toDateObj.diff(fromDateObj, 'days');
+
+
+    let key = '';
+    let values = [];
+    let text = null;
+
+    if (format) {
+      let years, months, days, hours, minutes, seconds;
+      years = diffObj1.years > 1 ? '2' : diffObj1.years; //  months = diffObj1.months > 1 ? '2' : diffObj1.months;
+      //  days = diffObj1.days > 1 ? '2' : diffObj1.days;
+
+      days = diff.yd > 1 ? '2' : diff.yd;
+      hours = diffObj1.hours > 1 ? '2' : diffObj1.hours;
+      minutes = diffObj1.minutes > 1 ? '2' : diffObj1.minutes; //seconds = diffObj1.seconds > 1 ? '2' : diffObj1.seconds;
+      // let pattern = '' + years + months + days + hours + minutes + seconds;
+
+      let count = 0;
+      let pattern = [years, days, hours, minutes].reduce((res, next) => {
+        if (count === 2 || next === 0) {
+          res = `${res}0`;
+        } else if (next !== 0) {
+          count++;
+          res = res + next;
+        } else {
+          res = res + next;
+        }
+
+        return res;
+      }, '');
+      let value = format(diffObj1, pattern);
+
+      if (value && typeof value === 'object') {
+        key = value.key;
+        values = getValues(value.params, diffObj);
+        isSuffixEnable = true;
+      } else if (typeof value === 'string') {
+        text = formatDate(toDateObj, value);
+      }
+    } else {
+      let dateObj = new Date(toDateObj);
+      let curDateObj = new Date(fromDateObj);
+      let diffDayType = diffObj1.yDays; //In this condition, to calculate different days we have copied it from live --> diffDayType
+
+      if (isOverdue && dateObj.getDate() < curDateObj.getDate() && diffObj1.yDays == 0) {
+        diffDayType = -1;
+      }
+
+      if (!isOverdue) {
+        let diffHr = dateObj.getHours() - curDateObj.getHours();
+
+        if (diffHr < 0) {
+          diffDayType += 1;
+        } else if (diffHr == 0) {
+          let diffMins = dateObj.getMinutes() - curDateObj.getMinutes();
+
+          if (diffMins < 0) {
+            diffDayType += 1;
+          } else if (diffMins == 0) {
+            let diffSec = dateObj.getSeconds() - curDateObj.getSeconds();
+
+            if (diffSec < 0) {
+              diffDayType += 1;
+            }
+          }
+        }
+      }
+
+      if (diff.y === 0 && (diffDayType === 0 || diffDayType === 1)) {
+        if (today && dateObj.getDate() === curDateObj.getDate()) {
+          if (typeof today === 'object') {
+            key = today.key;
+            values = getValues(today.params, diffObj);
+            isSuffixEnable = true;
+          } else if (typeof today === 'string') {
+            text = formatDate(toDateObj, today);
+          }
+        } else if (yesterday && dateObj.getMonth() === curDateObj.getMonth() && dateObj.getDate() < curDateObj.getDate() || yesterday && dateObj.getMonth() < curDateObj.getMonth()) {
+          if (typeof yesterday === 'object') {
+            key = yesterday.key;
+            values = getValues(yesterday.params, diffObj);
+          } else if (typeof yesterday === 'string') {
+            text = formatDate(toDateObj, yesterday);
+          }
+        } else if (tomorrow && !isOverdue && diff.y === 0 && diffDayType === 1) {
+          if (typeof tomorrow === 'object') {
+            key = tomorrow.key;
+            values = getValues(tomorrow.params, diffObj);
+          } else if (typeof tomorrow === 'string') {
+            text = formatDate(toDateObj, tomorrow);
+          }
+        } else {
+          let value = others(diffObj1);
+
+          if (typeof value === 'object') {
+            key = value.key;
+            values = getValues(value.params, diffObj);
+            isSuffixEnable = true;
+          } else if (typeof value === 'string') {
+            text = formatDate(toDateObj, value);
+          }
+        }
+      } else {
+        let value = others(diffObj1);
+
+        if (typeof value === 'object') {
+          key = value.key;
+          values = getValues(value.params, diffObj);
+          isSuffixEnable = true;
+        } else if (typeof value === 'string') {
+          text = formatDate(toDateObj, value);
+        }
+      }
+    }
+
+    let key1 = isSuffixEnable && suffix != '' ? `${key}.${suffix}` : key;
+    return text || getI18NValue(key1, values);
+  };
+}
+let oneYearInMillis = 31536000000;
+let oneDayInMillis = 86400000;
+let oneHourInMillis = 3600000;
+let oneMinuteInMillis = 60000;
+
+function convertAsNonExponential(number) {
+  if (number.toString().toLowerCase().indexOf('e') !== -1) {
+    return number.toFixed(20);
+  }
+
+  return number;
+}
+
+export function getDiffObj(diff) {
+  diff = Math.abs(diff);
+  let diffYears = diff / oneYearInMillis;
+  diffYears = convertAsNonExponential(diffYears);
+  let diffDays = diff % oneYearInMillis / oneDayInMillis;
+  diffDays = convertAsNonExponential(diffDays);
+  let diffHours = diff % oneDayInMillis / oneHourInMillis;
+  diffHours = convertAsNonExponential(diffHours);
+  let diffMinutes = diff % oneDayInMillis % oneHourInMillis / oneMinuteInMillis;
+  let diffSeconds = diff % oneDayInMillis % oneHourInMillis % oneMinuteInMillis / 1000;
+  diffDays = parseInt(diffDays);
+  diffHours = parseInt(diffHours);
+  diffMinutes = parseInt(diffMinutes);
+  diffSeconds = parseInt(diffSeconds);
+  diffYears = parseInt(diffYears);
+  return {
+    y: diffYears,
+    yd: diffDays,
+    h: diffHours,
+    m: diffMinutes,
+    s: diffSeconds
+  };
+}
+export function getLyears(from, to) {
+  let dFrom = new Date(from),
+      dTo = new Date(to);
+  let fromYear = dFrom.getFullYear();
+  let toYear = dTo.getFullYear();
+  let arrayofLeapYears = [];
+
+  for (let loopYear = fromYear; loopYear <= toYear; loopYear++) {
+    if (loopYear % 4 === 0 && loopYear % 100 !== 0 || loopYear % 100 === 0 && loopYear % 400 === 0) {
+      arrayofLeapYears.push(loopYear);
+    }
+  }
+
+  return arrayofLeapYears.length;
+}
+export function getSuffix(min, ago, later) {
+  let suffix;
+
+  if (min < 0) {
+    suffix = ago || '';
+  } else if (min > 0) {
+    suffix = later || '';
+  } else {
+    suffix = '';
+  }
+
+  return suffix;
+}