@zohodesk/i18n 1.0.0-beta.2 → 1.0.0-beta.21

package/src/index.js

@@ -0,0 +1,33 @@
+export {
+  formatDate,
+  pad,
+  replaceI18NValuesWithRegex,
+  unescapeUnicode,
+  getValues,
+  getI18NInfo,
+  isToday,
+  isYesterday,
+  isTomorrow,
+  isWithinAWeek,
+  isTwoWeeksOrMore,
+  userDateFormat,
+  getDiffObj,
+  getLyears,
+  getSuffix,
+  getDatePatternWithoutYear,
+  setLocalizedData
+} from './utils';
+import { getI18NValue as getI18NValue1 } from './utils';
+export { I18NContext } from './I18NContext';
+export {
+  default as I18NProvider,
+  i18NProviderUtils,
+} from './components/I18NProvider';
+export { default as I18N } from './components/I18N';
+export { default as HOCI18N } from './components/HOCI18N';
+export { default as FormatText } from './components/FormatText';
+export { default as PluralFormat } from './components/PluralFormat';
+export { default as DateTimeDiffFormat } from './components/DateTimeDiffFormat';
+export { default as UserTimeDiffFormat } from './components/UserTimeDiffFormat';
+export const getI18NValue = (i18n, key, values) =>
+  getI18NValue1(i18n)(key, values);

package/src/utils.js

@@ -0,0 +1,527 @@
+import datetime from '@zohodesk/datetimejs';
+
+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: dateFormat.dayNames[D],
+    dddd: dateFormat.dayNames[D + 7],
+    D: d,
+    DD: pad(d, 2),
+    DDD: dateFormat.dayNames[D],
+    DDDD: dateFormat.dayNames[D + 7],
+    M: m + 1,
+    MM: pad(m + 1, 2),
+    MMM: dateFormat.monthNames[m],
+    MMMM: 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 ? dateFormat.timeNames[0] : dateFormat.timeNames[1],
+    A: H < 12 ? dateFormat.timeNames[6] : dateFormat.timeNames[7],
+    T: H < 12 ? dateFormat.timeNames[4] : 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]);
+}
+
+let localizedData = {};
+
+export function setLocalizedData(data) {
+  localizedData = data;
+}
+export function getLocalizedValue({
+  type,
+  moduleName,
+  apiName,
+  fieldValue
+} = {}) {
+  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; 
+    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) : null;
+    let i18nStr = i18n[key];
+    if (i18nStr === undefined) {
+      return localizedValue || key;
+    }
+    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;
+}

package/es/components/NewDateFormat.js

@@ -1,50 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-
-import { getFormatedDate } from '../utils';
-import FormatText from './FormatText';
-import { I18NContext } from '../I18NContext';
-
-export default function NewDateFormat(props, context) {
-  var currentTime = new Date();
-  var to = props.to,
-      today = props.today,
-      yesterday = props.yesterday,
-      tomorrow = props.tomorrow,
-      others = props.others,
-      ago = props.ago,
-      later = props.later,
-      format = props.format,
-      titleFormat = props.titleFormat,
-      titleString = props.titleString,
-      className = props.className,
-      displayType = props.displayType,
-      calculateFrom = props.calculateFrom;
-
-  calculateFrom = calculateFrom === undefined ? currentTime : calculateFrom;
-  var tzData = context.tzData;
-
-  var formatResponse = getFormatedDate(to, today, yesterday, tomorrow, others, ago, later, format, titleFormat, titleString, calculateFrom, tzData);
-  var isI18nValue = formatResponse.isFormatText;
-  if (isI18nValue) {
-    var i18nText = formatResponse.i18nText,
-        values = formatResponse.values,
-        _title = formatResponse.title;
-
-    return React.createElement(FormatText, {
-      i18NKey: i18nText,
-      values: values,
-      className: className,
-      'data-title': _title
-    });
-  }
-  var title = formatResponse.title,
-      formatedDate = formatResponse.formatedDate;
-
-  return React.createElement(
-    'span',
-    { className: className, 'data-title': title },
-    formatedDate
-  );
-}
-NewDateFormat.contextType = I18NContext;