@zohodesk/i18n 1.0.0-beta.4 → 1.0.0-beta.41-murphy

package/src/utils/index.js

@@ -0,0 +1,644 @@
+import datetime from '@zohodesk/datetimejs';
+import {
+  i18NProviderUtils
+} from '../components/I18NProvider';
+import { reportI18NError, I18N_ERROR_TYPES, getFallbackText } from './errorReporter';
+
+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, width = 1, z) {
+  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(params = [], diff) {
+  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, keyString = '') {
+  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({
+  type,
+  moduleName,
+  deptName,
+  folderName,
+  reportId,
+  reportName,
+  apiName,
+  fieldValue,
+  layoutName
+} = {}) {
+  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') {
+    reportI18NError(I18N_ERROR_TYPES.UNDEFINED_OBJECT, 'i18n_object');
+    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) {
+      const isNumeric = /^\d+$/.test(finalKey);
+      const errorType = isNumeric
+        ? I18N_ERROR_TYPES.NUMERIC_FALLBACK
+        : I18N_ERROR_TYPES.MISSING_KEY;
+
+      reportI18NError(errorType, finalKey);
+      return localizedValue || getFallbackText(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 (
+    to,
+    { today, yesterday, tomorrow, others },
+    ago,
+    later,
+    isSuffixEnable = false,
+    format
+  ) => {
+    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;
+}