@zohodesk/components 1.0.0-temp-44 → 1.0.0-temp-47

package/lib/utils/__tests__/debounce.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _debounce = require("../debounce");
+
+describe('debounce specification', function () {
+  beforeEach(function () {
+    jest.useFakeTimers();
+  });
+  it('should call immediate', function () {
+    var mockfn = jest.fn();
+    var dMockfn = (0, _debounce.debounce)(mockfn, 1000, true);
+    dMockfn(); //expect(setTimeout).toHaveBeenCalledTimes(1);
+
+    expect(mockfn.mock.calls.length).toBe(1);
+  });
+  it('should call two times but it invoke multiple times', function () {
+    var mockfn = jest.fn();
+    var dMockfn = (0, _debounce.debounce)(mockfn, 1000, true);
+    dMockfn();
+    dMockfn();
+    dMockfn();
+    dMockfn();
+    dMockfn();
+    setTimeout(function () {
+      expect(mockfn.mock.calls.length).toBe(2);
+    }, 1000);
+  });
+  it('should call one time but it invoke multiple times', function () {
+    var mockfn = jest.fn();
+    var dMockfn = (0, _debounce.debounce)(mockfn, 1000);
+    dMockfn();
+    dMockfn();
+    dMockfn();
+    dMockfn();
+    dMockfn();
+    setTimeout(function () {
+      expect(mockfn.mock.calls.length).toBe(1);
+    }, 1000);
+  });
+});

package/lib/utils/__tests__/getInitial.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _getInitial = require("../getInitial");
+
+describe('getInitial specification', function () {
+  it('first name alone', function () {
+    expect((0, _getInitial.getInitial)('vimalesan')).toEqual('V');
+  });
+  it('last name alone', function () {
+    expect((0, _getInitial.getInitial)(null, 'vimalesan')).toEqual('VI');
+  });
+  it('first name and last name alone', function () {
+    expect((0, _getInitial.getInitial)('vimalesan', 'a')).toEqual('VA');
+  });
+  it('last name with single character', function () {
+    expect((0, _getInitial.getInitial)(null, 'v')).toEqual('V');
+  });
+});
+describe('getInitialByPattern specification', function () {
+  it('first name and last name pattern', function () {
+    expect((0, _getInitial.getInitialByPattern)('vimalesan', 'a', ['FIRST_NAME', 'LAST_NAME'])).toEqual('VA');
+  });
+  it('last name and first name pattern', function () {
+    expect((0, _getInitial.getInitialByPattern)('vimalesan', 'a', ['LAST_NAME', 'FIRST_NAME'])).toEqual('AV');
+  });
+});

package/lib/utils/constant.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LAST_NAME = exports.FIRST_NAME = void 0;
+var FIRST_NAME = 'FIRST_NAME';
+exports.FIRST_NAME = FIRST_NAME;
+var LAST_NAME = 'LAST_NAME';
+exports.LAST_NAME = LAST_NAME;

package/lib/utils/constructFullName.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.constructFullNameByPattern = constructFullNameByPattern;
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function constructFullName(firstName, lastName) {
+  return "".concat(firstName ? "".concat(firstName).concat(lastName ? ' ' : '') : '').concat(lastName ? lastName : '');
+}
+
+function constructFullNameByPattern(firstName, lastName, namePattern) {
+  var _namePattern = _slicedToArray(namePattern, 2),
+      name0 = _namePattern[0],
+      name1 = _namePattern[1];
+
+  if (name0 === 'FIRST_NAME' && name1 === 'LAST_NAME') {
+    return constructFullName(firstName, lastName);
+  } else if (name0 === 'LAST_NAME' && name1 === 'FIRST_NAME') {
+    return constructFullName(lastName, firstName);
+  }
+}

package/lib/utils/datetime/common.js

@@ -0,0 +1,233 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pad = pad;
+exports.formatDate = formatDate;
+exports.replaceI18NValuesWithRegex = replaceI18NValuesWithRegex;
+exports.unescapeUnicode = unescapeUnicode;
+exports.getValues = getValues;
+exports.getI18NValue = getI18NValue;
+exports.getI18NInfo = getI18NInfo;
+exports.isToday = isToday;
+exports.isYesterday = isYesterday;
+exports.isTomorrow = isTomorrow;
+exports.isWithinAWeek = isWithinAWeek;
+exports.isTwoWeeksOrMore = isTwoWeeksOrMore;
+exports.getDiffObj = getDiffObj;
+exports.getMonthEnd = getMonthEnd;
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var 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']
+};
+
+function pad(n) {
+  var width = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  var z = arguments.length > 2 ? arguments[2] : undefined;
+  z = z || '0';
+  n = "".concat(n);
+  return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
+}
+
+function formatDate(dateMill, mask) {
+  var date = new Date(dateMill);
+  var d = date.getDate();
+  var D = date.getDay();
+  var m = date.getMonth();
+  var y = date.getFullYear();
+  var H = date.getHours();
+  var M = date.getMinutes();
+  var s = date.getSeconds();
+  var L = date.getMilliseconds();
+  var 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]
+  };
+  var token = /D{1,4}|d{1,4}|M{1,4}|YYYY|yyyy|YY|yy?|([HhmsA])\1?|[LloSZWN]|\[[^\]]*\]|'[^']*'/g;
+  var dat = mask.replace(token, function (match) {
+    if (match in flags) {
+      return flags[match];
+    }
+
+    return match.slice(1, match.length - 1);
+  });
+  return dat;
+}
+
+function replaceI18NValuesWithRegex(i18nStr, values) {
+  if (typeof values !== 'undefined') {
+    if (Array.isArray(values)) {
+      for (var i = 0; i < values.length; i++) {
+        i18nStr = i18nStr.replace(new RegExp("\\{".concat(i, "\\}"), 'g'), values[i]);
+      }
+    } else {
+      i18nStr = i18nStr.replace(new RegExp('\\{0\\}', 'g'), values);
+    }
+  }
+
+  return i18nStr;
+}
+
+function unescapeUnicode(str) {
+  return str.replace(/\\u([a-fA-F0-9]{4})/g, function (g, m1) {
+    return String.fromCharCode(parseInt(m1, 16));
+  });
+}
+
+function getValues() {
+  var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var diff = arguments.length > 1 ? arguments[1] : undefined;
+  return params.map(function (param) {
+    return diff[param];
+  });
+}
+
+function getI18NValue(i18n) {
+  if (typeof i18n === 'undefined') {
+    return function (key) {
+      return key;
+    };
+  }
+
+  return function (key, values) {
+    var i18nStr = i18n[key];
+
+    if (i18nStr === undefined) {
+      return key;
+    }
+
+    i18nStr = replaceI18NValuesWithRegex(i18nStr, values);
+    return unescapeUnicode(i18nStr);
+  };
+} // function getValues(params = [], diff) {
+//   return params.map(param => {
+//     return diff[param];
+//   });
+// }
+
+
+function getI18NInfo(toDateObj, props, diffObj) {
+  var key = null,
+      values,
+      text = null;
+
+  if (typeof props === 'function') {
+    var 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: key,
+    values: values,
+    text: text
+  };
+}
+
+function isToday(fromDate, toDate) {
+  var TODAY = toDate.clone().startOf('day');
+  return fromDate.isSame(TODAY, 'd');
+}
+
+function isYesterday(fromDate, toDate) {
+  var YESTERDAY = toDate.clone().subtract(1, 'days').startOf('day');
+  return fromDate.isSame(YESTERDAY, 'd');
+}
+
+function isTomorrow(fromDate, toDate) {
+  return isYesterday(toDate, fromDate);
+}
+
+function isWithinAWeek(fromDate, toDate) {
+  var A_WEEK_OLD = toDate.clone().subtract(7, 'days').startOf('day');
+  return fromDate.isAfter(A_WEEK_OLD);
+}
+
+function isTwoWeeksOrMore(fromDate, toDate) {
+  return !isWithinAWeek(fromDate, toDate);
+}
+
+var oneYearInMillis = 31536000000;
+var oneDayInMillis = 86400000;
+var oneHourInMillis = 3600000;
+var oneMinuteInMillis = 60000;
+
+function convertAsNonExponential(number) {
+  if (number.toString().toLowerCase().indexOf('e') !== -1) {
+    return number.toFixed(20);
+  }
+
+  return number;
+}
+
+function getDiffObj(diff) {
+  diff = Math.abs(diff);
+  var diffYears = diff / oneYearInMillis;
+  diffYears = convertAsNonExponential(diffYears);
+  var diffDays = diff % oneYearInMillis / oneDayInMillis;
+  diffDays = convertAsNonExponential(diffDays);
+  var diffHours = diff % oneDayInMillis / oneHourInMillis;
+  diffHours = convertAsNonExponential(diffHours);
+  var diffMinutes = diff % oneDayInMillis % oneHourInMillis / oneMinuteInMillis;
+  var 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
+  };
+}
+
+function getMonthEnd(month, year) {
+  var monthend = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  var isLeapYear = year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+
+  if (month === 1 && isLeapYear) {
+    return 29;
+  }
+
+  return monthend[month];
+}

package/lib/utils/debounce.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.debounce = debounce;
+
+function debounce(func, wait, immediate) {
+  var timeout;
+  return function () {
+    var context = this,
+        args = arguments;
+
+    var later = function later() {
+      timeout = null;
+
+      if (!immediate) {
+        func.apply(context, args);
+      }
+    };
+
+    var callNow = immediate && !timeout;
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+
+    if (callNow) {
+      func.apply(context, args);
+    }
+  };
+}