@spothero/ui 15.0.0-beta.2 → 15.0.0-beta.3

package/backlog/utils/date.js

@@ -0,0 +1,233 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ssrWindow = require("ssr-window");
+
+var _isDate = _interopRequireDefault(require("lodash/isDate"));
+
+var _isObject = _interopRequireDefault(require("lodash/isObject"));
+
+var _isString = _interopRequireDefault(require("lodash/isString"));
+
+var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
+
+var splitTextDate = function splitTextDate(date, delimeter) {
+  var d = date.split(delimeter);
+  return new Date(d[2], d[0] - 1, d[1]);
+};
+
+var splitMobileDate = function splitMobileDate(date) {
+  var d = date.split('-');
+  return new Date(d[0], d[1] - 1, d[2]);
+};
+/**
+ * Utilities for working with dates.
+ * @module DateUtils
+ */
+
+
+var DateUtils = {
+  // /**
+  //  * Check whether input type of 'date' is supported in the current browser.
+  //  * @static
+  //  * @function supportsDateInput
+  //  * @example
+  //  * DateUtils.supportsDateInput();
+  //  * @returns {Boolean} - Whether the input type is supported.
+  //  */
+  // supportsDateInput() {
+  //     const fakeValue = 'not-a-date';
+  //     const input = document.createElement('input');
+  //
+  //     input.setAttribute('type', 'date');
+  //     input.setAttribute('value', fakeValue);
+  //
+  //     return input.value !== fakeValue;
+  // },
+  // /**
+  //  * Gets the closest match to the user's current time zone.
+  //  * @static
+  //  * @function getTimeZone
+  //  * @example
+  //  * DateUtils.getTimeZone(); // 'America/Chicago'
+  //  * @returns {String} - The user's current time zone.
+  //  */
+  // getTimeZone() {
+  //     if (
+  //         window.Intl &&
+  //         isObject(window.Intl) &&
+  //         window.Intl.DateTimeFormat().resolvedOptions().timeZone
+  //     ) {
+  //         return window.Intl.DateTimeFormat().resolvedOptions().timeZone;
+  //     } else {
+  //         return moment.tz.guess();
+  //     }
+  // },
+  // /**
+  //  * Converts a mobile input date to a string using the specified format.
+  //  * @static
+  //  * @function convertToDesktop
+  //  * @param {String} date - The input value in the format YYYY-MM-DD.
+  //  * @param {String} [format='MM/DD/YYYY'] - The output format.
+  //  * @example
+  //  * DateUtils.convertToDesktop('1983-01-19');
+  //  * @returns {String} - The formatted date.
+  //  */
+  // convertToDesktop(date, format = 'MM/DD/YYYY') {
+  //     if (!isString(date)) {
+  //         throw new Error('The supplied date is not a string.');
+  //     }
+  //
+  //     if (date.indexOf('-') !== -1) {
+  //         return moment(splitMobileDate(date)).format(format);
+  //     } else {
+  //         return date;
+  //     }
+  // },
+  // /**
+  //  * Converts a desktop input date to the native mobile date format.
+  //  * @static
+  //  * @function convertToMobile
+  //  * @param {String} date - The input value in the format MM/DD/YYYY.
+  //  * @example
+  //  * DateUtils.convertToMobile('01/19/1983');
+  //  * @returns {String} - The mobile formatted date.
+  //  */
+  // convertToMobile(date) {
+  //     if (!isString(date)) {
+  //         throw new Error('The supplied date is not a string.');
+  //     }
+  //
+  //     if (date.indexOf('/') !== -1) {
+  //         return moment(splitTextDate(date, '/')).format('YYYY-MM-DD');
+  //     } else {
+  //         return date;
+  //     }
+  // },
+
+  /**
+   * Converts a string date from a text or date input to a date object.
+   * @static
+   * @function getAsDate
+   * @param {String} date - The date in the format MM/DD/YYYY (text input) or YYYY-MM-DD (date input).
+   * @example
+   * DateUtils.getAsDate('1983-01-19');
+   * DateUtils.getAsDate('01/19/1983');
+   * @returns {Date} - The date object.
+   */
+  getAsDate: function getAsDate(date) {
+    if (!(0, _isString.default)(date)) {
+      throw new Error('The supplied date is not a string.');
+    }
+
+    if (date.indexOf('-') !== -1) {
+      // date input
+      return splitMobileDate(date);
+    } else {
+      // text input
+      return splitTextDate(date, '/');
+    }
+  },
+
+  /**
+   * Converts a string date from a text or date input to a moment instance.
+   * @static
+   * @function getAsMoment
+   * @param {String} date - The date in the format MM/DD/YYYY (text input) or YYYY-MM-DD (date input).
+   * @example
+   * DateUtils.getAsMoment('1983-01-19');
+   * DateUtils.getAsMoment('01/19/1983');
+   * @returns {Moment} - The moment instance.
+   */
+  getAsMoment: function getAsMoment(date) {
+    if (!(0, _isString.default)(date)) {
+      throw new Error('The supplied date is not a string.');
+    }
+
+    if (date.indexOf('-') !== -1) {
+      // date input
+      return (0, _momentTimezone.default)(splitMobileDate(date));
+    } else {
+      // text input
+      return (0, _momentTimezone.default)(splitTextDate(date, '/'));
+    }
+  },
+
+  /**
+   * Combines a date moment with a time moment to return one moment instance.
+   * @static
+   * @function combineDateAndTime
+   * @param {Moment} date - The date as a moment instance.
+   * @param {Moment} time - The time as a moment instance.
+   * @example
+   * DateUtils.combineDateAndTime(moment(), moment().add(7, 'hours').add(23, 'minutes'));
+   * @returns {Moment} - The combined moment instance.
+   */
+  combineDateAndTime: function combineDateAndTime(date, time) {
+    if (!_momentTimezone.default.isMoment(date) || !_momentTimezone.default.isMoment(time)) {
+      throw new Error('The date and/or time supplied was not an instance of Moment.');
+    }
+
+    return date.hours(time.hours()).minutes(time.minutes());
+  },
+
+  /**
+   * Checks if one date is before another.
+   * @static
+   * @function isBefore
+   * @param {Date} dateToCheck - The date to check.
+   * @param {Date} dateToCompare - The date to check against.
+   * @param {Boolean} [useTime=false] - Whether to use the time in the comparison.
+   * @example
+   * DateUtils.isBefore(new Date(2016, 1, 19), new Date(2016, 3, 14));
+   * @returns {Boolean} - Whether the provided date is before the one being checked against.
+   */
+  isBefore: function isBefore(dateToCheck, dateToCompare) {
+    var useTime = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+    if (!(0, _isDate.default)(dateToCheck) || !(0, _isDate.default)(dateToCompare)) {
+      throw new Error('The dates supplied must be instances of the Date object.');
+    }
+
+    if (!useTime) {
+      dateToCheck.setHours(0, 0, 0, 0);
+      dateToCompare.setHours(0, 0, 0, 0);
+    }
+
+    return dateToCheck < dateToCompare;
+  },
+
+  /**
+   * Checks if one date is after another.
+   * @static
+   * @function isAfter
+   * @param {Date} dateToCheck - The date to check.
+   * @param {Date} dateToCompare - The date to check against.
+   * @param {Boolean} [useTime=false] - Whether to use the time in the comparison.
+   * @example
+   * DateUtils.isAfter(new Date(2016, 1, 19), new Date(2016, 3, 14));
+   * @returns {Boolean} - Whether the provided date is after the one being checked against.
+   */
+  isAfter: function isAfter(dateToCheck, dateToCompare) {
+    var useTime = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+    if (!(0, _isDate.default)(dateToCheck) || !(0, _isDate.default)(dateToCompare)) {
+      throw new Error('The dates supplied must be instances of the Date object.');
+    }
+
+    if (!useTime) {
+      dateToCheck.setHours(0, 0, 0, 0);
+      dateToCompare.setHours(0, 0, 0, 0);
+    }
+
+    return dateToCheck > dateToCompare;
+  }
+};
+var _default = DateUtils;
+exports.default = _default;

package/backlog/utils/dom.js

@@ -0,0 +1,441 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _isArray = _interopRequireDefault(require("lodash/isArray"));
+
+var _isString = _interopRequireDefault(require("lodash/isString"));
+
+var _includes = _interopRequireDefault(require("lodash/includes"));
+
+// import {document, window} from 'ssr-window';
+// import forEach from 'lodash/forEach';
+// import isArrayLikeObject from 'lodash/isArrayLikeObject';
+// import CustomEvent from 'custom-event';
+// import EnvironmentUtils from '../environment/environment';
+
+/**
+ * Utilities for working with the Document Object Model (DOM).
+ * @module DOMUtils
+ */
+var DOMUtils = {
+  // /**
+  //  * Returns the tag name of the specified element.
+  //  * @static
+  //  * @function tag
+  //  * @param {Element} el - The element to check the tag of.
+  //  * @param {Boolean} [lowercase=true] - Whether to normalize the tag name for comparison as lowercase.
+  //  * @example
+  //  * DOMUtils.tag(document.querySelector('.foo'));
+  //  * @returns {String} - The tag of the specified element.
+  //  */
+  // tag(el, lowercase = true) {
+  //     return lowercase ? el.nodeName.toLowerCase() : el.nodeName;
+  // },
+
+  /**
+   * Returns the element(s) matching the specified selector.
+   * @static
+   * @function el
+   * @param {String} selector - The selector of the element to query.
+   * @example
+   * DOMUtils.el('.foo');
+   * @returns {Element|Array} - The element or array of elements matching the selector.
+   */
+  el: function el(selector) {
+    var els = document.querySelectorAll(selector);
+
+    if (els.length > 1) {
+      return els;
+    } else {
+      return els[0];
+    }
+  },
+
+  /**
+   * Returns the element's parent or the closest ancestor matching the specified selector if provided.
+   * @static
+   * @function parent
+   * @param {String|Element} item - The selector or element to find the parent of.
+   * @param {String} [parentSelector] - The selector of the ancestor to find.
+   * @example
+   * DOMUtils.parent('.foo', '.bar');
+   * @returns {Element} - The parent of the item.
+   */
+  parent: function parent(item, parentSelector) {
+    var el = (0, _isString.default)(item) ? DOMUtils.el(item) : item;
+
+    if (!el) {
+      return;
+    }
+
+    if (parentSelector) {
+      var allParents = document.querySelectorAll(parentSelector);
+      var currentParent = el.parentNode;
+
+      while (currentParent && !(0, _includes.default)(allParents, currentParent)) {
+        currentParent = currentParent.parentNode;
+      }
+
+      return currentParent;
+    } else {
+      return el.parentNode;
+    }
+  },
+
+  /**
+   * Returns the attribute of the specified element.
+   * @static
+   * @function attr
+   * @param {String|Element} item - The selector or element to query.
+   * @param {String} attribute - The attribute to query.
+   * @example
+   * DOMUtils.attr('.foo', 'data-baz');
+   * @returns {String} - The value of the attribute.
+   */
+  attr: function attr(item, attribute) {
+    var el = (0, _isString.default)(item) ? DOMUtils.el(item) : item;
+
+    if (!el) {
+      return;
+    }
+
+    return el.getAttribute(attribute);
+  },
+
+  /**
+   * Adds a class to the specified element.
+   * @static
+   * @function addClass
+   * @param {String|Element} item - The selector or element to add the class to.
+   * @param {String|Array.<String>} className - The class(es) to add.
+   * @example
+   * DOMUtils.addClass(evt.currentTarget, 'foo');
+   * @returns {void}
+   */
+  addClass: function addClass(item, className) {
+    var el = (0, _isString.default)(item) ? DOMUtils.el(item) : item;
+
+    if (!el) {
+      return;
+    }
+
+    var classes = (0, _isString.default)(className) ? className.split(' ') : className;
+    classes.forEach(function (itemClassName) {
+      el.classList.add(itemClassName);
+    });
+  },
+
+  /**
+   * Removes a class from the specified element.
+   * @static
+   * @function removeClass
+   * @param {String|Element} item - The selector or element to remove the class from.
+   * @param {String|Array.<String>} className - The class(es) to remove.
+   * @example
+   * DOMUtils.removeClass(evt.currentTarget, 'foo');
+   * @returns {void}
+   */
+  removeClass: function removeClass(item, className) {
+    var el = (0, _isString.default)(item) ? DOMUtils.el(item) : item;
+
+    if (!el) {
+      return;
+    }
+
+    var classes = (0, _isString.default)(className) ? className.split(' ') : className;
+    classes.forEach(function (itemClassName) {
+      el.classList.remove(itemClassName);
+    });
+  },
+
+  /**
+   * Checks if an element has a specified class.
+   * @static
+   * @function hasClass
+   * @param {String|Element} item - The selector or element to check.
+   * @param {String} className - The class to check for.
+   * @example
+   * DOMUtils.hasClass(evt.currentTarget, 'foo');
+   * @returns {Boolean} - Whether the element has the class or not.
+   */
+  hasClass: function hasClass(item, className) {
+    var el = (0, _isString.default)(item) ? DOMUtils.el(item) : item;
+
+    if (!el) {
+      return false;
+    }
+
+    return el.classList.contains(className) || false;
+  },
+  // /**
+  //  * Toggles a class on or off for the specified element.
+  //  * @static
+  //  * @function toggleClass
+  //  * @param {String|Element} item - The selector or element to toggle the class on.
+  //  * @param {String} className - The class to toggle.
+  //  * @example
+  //  * DOMUtils.toggleClass(evt.currentTarget, 'foo');
+  //  * @returns {void}
+  //  */
+  // toggleClass(item, className) {
+  //     if (DOMUtils.hasClass(item, className)) {
+  //         DOMUtils.removeClass(item, className);
+  //     } else {
+  //         DOMUtils.addClass(item, className);
+  //     }
+  // },
+
+  /**
+   * Get the height of the specified element.
+   * @static
+   * @function height
+   * @param {String|Element} item - The selector or element to find the height of.
+   * @param {Boolean} [includeMargin=true] - Whether to include the margins in the calculation effectively getting the outerHeight.
+   * @param {Boolean} [includePadding=true] - Whether to include the padding in the calculation.
+   * @example
+   * DOMUtils.height('.foo');
+   * @returns {Number} - The height of the element.
+   */
+  height: function height(item) {
+    var includeMargin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    var includePadding = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    var el = (0, _isString.default)(item) ? DOMUtils.el(item) : item;
+
+    if (!el) {
+      return 0;
+    }
+
+    var _window$getComputedSt = window.getComputedStyle(el),
+        marginTop = _window$getComputedSt.marginTop,
+        marginBottom = _window$getComputedSt.marginBottom,
+        paddingTop = _window$getComputedSt.paddingTop,
+        paddingBottom = _window$getComputedSt.paddingBottom;
+
+    var height = el.offsetHeight;
+
+    if (includeMargin) {
+      height += parseInt(marginTop, 10) + parseInt(marginBottom, 10);
+    }
+
+    if (!includePadding) {
+      height -= parseInt(paddingTop, 10) + parseInt(paddingBottom, 10);
+    }
+
+    return height;
+  },
+  // /**
+  //  * Get the width of the specified element.
+  //  * @static
+  //  * @function width
+  //  * @param {String|Element} item - The selector or element to find the width of.
+  //  * @param {Boolean} [includeMargin=true] - Whether to include the margins in the calculation effectively getting the outerWidth.
+  //  * @param {Boolean} [includePadding=true] - Whether to include the padding in the calculation.
+  //  * @example
+  //  * DOMUtils.width('.foo');
+  //  * @returns {Number} - The width of the element.
+  //  */
+  // width(item, includeMargin = true, includePadding = true) {
+  //     const el = isString(item) ? DOMUtils.el(item) : item;
+  //
+  //     if (!el) {
+  //         return 0;
+  //     }
+  //
+  //     const {
+  //         marginLeft,
+  //         marginRight,
+  //         paddingLeft,
+  //         paddingRight,
+  //     } = window.getComputedStyle(el);
+  //     let width = el.offsetWidth;
+  //
+  //     if (includeMargin) {
+  //         width += parseInt(marginLeft, 10) + parseInt(marginRight, 10);
+  //     }
+  //
+  //     if (!includePadding) {
+  //         width -= parseInt(paddingLeft, 10) + parseInt(paddingRight, 10);
+  //     }
+  //
+  //     return width;
+  // },
+
+  /**
+   * Removes element(s) from the DOM.
+   * @static
+   * @function remove
+   * @param {String|Element|Array} items - The selector or element(s) to remove from the DOM.
+   * @example
+   * DOMUtils.remove('.class-to-remove');
+   * @returns {void}
+   */
+  remove: function remove(items) {
+    var el = (0, _isString.default)(items) ? DOMUtils.el(items) : items;
+
+    if (!el) {
+      return;
+    }
+
+    if ((0, _isArray.default)(el) || el instanceof NodeList) {
+      var len = el.length;
+      var i = 0;
+
+      for (i; i < len; ++i) {
+        el.outerHTML = '';
+      }
+    } else {
+      el.outerHTML = '';
+    }
+  },
+  //
+  // /**
+  //  * Adds event listener for an element or NodeList.
+  //  * @static
+  //  * @function addEventListener
+  //  * @param {Object} data - The data to pass to the function.
+  //  * @param {String} data.event - The DOM event to take action on.
+  //  * @param {String|Element} [data.target='document'] - The selector or element to attach the event to.
+  //  * @param {Function} data.handler - The function to run when the event triggers.
+  //  * @example
+  //  * DOMUtils.addEventListener({target: '.foo', event: 'click', handler: functionName});
+  //  * @returns {void}
+  //  */
+  // addEventListener({event, target = 'document', handler}) {
+  //     if (target && target !== 'document') {
+  //         const el = isString(target) ? DOMUtils.el(target) : target;
+  //
+  //         if (!el) {
+  //             return;
+  //         }
+  //
+  //         if (isArrayLikeObject(el)) {
+  //             forEach(el, thisEl => {
+  //                 thisEl.addEventListener(event, handler);
+  //             });
+  //         } else {
+  //             el.addEventListener(event, handler);
+  //         }
+  //     } else {
+  //         document.addEventListener(event, handler, {capture: true});
+  //     }
+  // },
+  //
+  // /**
+  //  * Removes event listener for an element or NodeList.
+  //  * @static
+  //  * @function removeEventListener
+  //  * @param {Object} data - The data to pass to the function.
+  //  * @param {String} data.event - The DOM event to remove.
+  //  * @param {String|Element} [data.target='document'] - The selector or element to remove the event from.
+  //  * @param {Function} data.handler - The function that is triggered to handle the event.
+  //  * @example
+  //  * DOMUtils.removeEventListener({target: '.foo', event: 'click', handler: functionName});
+  //  * @returns {void}
+  //  */
+  // removeEventListener({event, target = 'document', handler}) {
+  //     if (target && target !== 'document') {
+  //         const el = isString(target) ? DOMUtils.el(target) : target;
+  //
+  //         if (!el) {
+  //             return;
+  //         }
+  //
+  //         if (isArrayLikeObject(el)) {
+  //             forEach(el, thisEl => {
+  //                 thisEl.removeEventListener(event, handler);
+  //             });
+  //         } else {
+  //             el.removeEventListener(event, handler);
+  //         }
+  //     } else {
+  //         document.removeEventListener(event, handler);
+  //     }
+  // },
+  //
+  // /**
+  //  * Creates and dispatches a custom event, with or without data.
+  //  * @static
+  //  * @function sendCustomEvent
+  //  * @param {String} eventName - The name for the custom event.
+  //  * @param {Object} [data=null] - The data to send with the custom event.
+  //  * @example
+  //  * DOMUtils.sendCustomEvent('open-my-mind', {mind: 'free'});
+  //  * @returns {void}
+  //  */
+  // sendCustomEvent(eventName, data = null) {
+  //     if (!eventName) {
+  //         throw new Error(
+  //             `The 'eventName' is required when sending custom events.`
+  //         );
+  //     }
+  //
+  //     const customEvent = new CustomEvent(eventName, {detail: data});
+  //
+  //     document.dispatchEvent(customEvent);
+  // },
+
+  /**
+   * Gets the offset of an element relative to the document.
+   * @static
+   * @function getDocumentOffset
+   * @param {String|Element} item - The selector or element to get the offset of.
+   * @example
+   * DOMUtils.getDocumentOffset('.foo');
+   * @returns {Object} - The top and left values of the offset.
+   */
+  getDocumentOffset: function getDocumentOffset(item) {
+    var el = (0, _isString.default)(item) ? DOMUtils.el(item) : item;
+    var scrollLeft = window.pageXOffset || document.documentElement.scrollLeft;
+    var scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+    var rect = el ? el.getBoundingClientRect() : {
+      top: 0,
+      left: 0
+    };
+    return {
+      top: rect.top + scrollTop,
+      left: rect.left + scrollLeft
+    };
+  } //
+  // /**
+  //  * Loads a script into an element in the document. Pass a fully qualified, exact URL to enable proper matching against a pre-existing script of the same path.
+  //  * @static
+  //  * @function loadScript
+  //  * @param {String} src - The exact script path to load.
+  //  * @param {String} [appendTo='head'] - Where to append the script ('head', 'body') in the document.
+  //  * @example
+  //  * DOMUtils.loadScript({src: 'https://js.stripe.com/v3/'});
+  //  * @returns {Promise} - The promise that is either fulfilled or rejected as a result of loading the script.
+  //  */
+  // loadScript({src, appendTo = 'head'}) {
+  //     if (!EnvironmentUtils.isBrowser()) {
+  //         return;
+  //     }
+  //
+  //     const isDuplicate = [...document.querySelectorAll('script')].some(
+  //         script => {
+  //             return script.src === src;
+  //         }
+  //     );
+  //
+  //     return new Promise((resolve, reject) => {
+  //         const s = document.createElement('script');
+  //
+  //         s.src = src;
+  //         s.onload = resolve;
+  //         s.onerror = reject;
+  //
+  //         if (!isDuplicate) {
+  //             document[appendTo].appendChild(s);
+  //         }
+  //     });
+  // },
+
+};
+var _default = DOMUtils;
+exports.default = _default;