@shopgate/pwa-common 7.30.0-alpha.6 → 7.30.0-alpha.8

package/helpers/data/index.js

@@ -1,25 +1,54 @@
-function _typeof(obj){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);}function _defineProperty(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true});}else{obj[key]=value;}return obj;}function _extends(){_extends=Object.assign||function(target){for(var i=1;i<arguments.length;i++){var source=arguments[i];for(var key in source){if(Object.prototype.hasOwnProperty.call(source,key)){target[key]=source[key];}}}return target;};return _extends.apply(this,arguments);}function _toArray(arr){return _arrayWithHoles(arr)||_iterableToArray(arr)||_nonIterableRest();}function _nonIterableRest(){throw new TypeError("Invalid attempt to destructure non-iterable instance");}function _iterableToArray(iter){if(Symbol.iterator in Object(iter)||Object.prototype.toString.call(iter)==="[object Arguments]")return Array.from(iter);}function _arrayWithHoles(arr){if(Array.isArray(arr))return arr;}import{logger}from'@shopgate/pwa-core/helpers';import{isAndroidOs}from'@shopgate/pwa-core';import{isObject,isArray}from"../validation";/**
+import "core-js/modules/es.array.reduce.js";
+import "core-js/modules/es.string.replace.js";
+import { logger } from '@shopgate/pwa-core/helpers';
+import { isAndroidOs } from '@shopgate/pwa-core';
+import { isObject, isArray } from "../validation";
+
+/**
  * Tests if the prop is an object or an array.
  * @param {*} prop The property to test.
  * @return {boolean}
- */var isObjectOrArray=function isObjectOrArray(prop){return isObject(prop)||isArray(prop);};/**
+ */
+const isObjectOrArray = prop => isObject(prop) || isArray(prop);
+
+/**
  * Remove the first element of the array.
  * @param {Array} array The array to remove the first element from.
  * @returns {Array} The reduced array.
- */export var shift=function shift(_ref){var _ref2=_toArray(_ref),newArray=_ref2.slice(1);return newArray;};/**
+ */
+export const shift = ([, ...newArray]) => newArray;
+
+/**
  * Returns a new object without certain keys.
  * @param {Object} obj The original object.
  * @param {Array} [keys=[]] An array of unwanted keys.
  * @return {Object} The reduced object.
- */export var objectWithoutProps=function objectWithoutProps(obj){var keys=arguments.length>1&&arguments[1]!==undefined?arguments[1]:[];var target={};Object.keys(obj).forEach(function(key){if(!keys.includes(key)){target[key]=obj[key];}});return target;};/**
+ */
+export const objectWithoutProps = (obj, keys = []) => {
+  const target = {};
+  Object.keys(obj).forEach(key => {
+    if (!keys.includes(key)) {
+      target[key] = obj[key];
+    }
+  });
+  return target;
+};
+
+/**
  * Checks if a URL is an external URL.
  * @param {string} url The URL to check.
  * @return {boolean}
- */export var isExternal=function isExternal(url){return url.includes('http://')||url.includes('https://')||url.includes('//');};/**
+ */
+export const isExternal = url => url.includes('http://') || url.includes('https://') || url.includes('//');
+
+/**
  * Checks whether the url is an HTTPS url.
  * @param {string} url The url to open.
  * @return {boolean}
- */export var isHTTPS=function isHTTPS(){var url=arguments.length>0&&arguments[0]!==undefined?arguments[0]:'';return url.startsWith('https://');};/**
+ */
+export const isHTTPS = (url = '') => url.startsWith('https://');
+
+/**
  * Returns the actual url to the image, by adding url parameters with the dimensions for img-cdn
  * @param {string} src Source to the image.
  * @param {Object} dimension Dimension of the requested image.
@@ -27,43 +56,148 @@ function _typeof(obj){if(typeof Symbol==="function"&&typeof Symbol.iterator==="s
  * @param {number} dimension.height Height in pixels.
  * @deprecated use getFullImageSource from @shopgate/engage/core/helpers instead
  * @returns {string}
- */export var getActualImageSource=function getActualImageSource(src,_ref3){var width=_ref3.width,height=_ref3.height;if(src&&src.includes('images.shopgate.services')){var fillColor='FFFFFF,1';var format=isAndroidOs?'webp':'jpeg';return"".concat(src,"&format=").concat(format,"&width=").concat(width,"&height=").concat(height,"&quality=75&fill=").concat(fillColor.replace('#',''));}if(src&&src.startsWith('https://img-cdn.shopgate.com')&&!src.includes('?')){return"".concat(src,"?w=").concat(width,"&h=").concat(height,"&q=70&zc=resize&fillc=FFFFFF");}return src;};/**
+ */
+export const getActualImageSource = (src, {
+  width,
+  height
+}) => {
+  if (src && src.includes('images.shopgate.services')) {
+    const fillColor = 'FFFFFF,1';
+    const format = isAndroidOs ? 'webp' : 'jpeg';
+    return `${src}&format=${format}&width=${width}&height=${height}&quality=75&fill=${fillColor.replace('#', '')}`;
+  }
+  if (src && src.startsWith('https://img-cdn.shopgate.com') && !src.includes('?')) {
+    return `${src}?w=${width}&h=${height}&q=70&zc=resize&fillc=FFFFFF`;
+  }
+  return src;
+};
+
+/**
  * Finds the index of a property inside an array.
  * @param {Array} arr The array to check.
  * @param {Function} fn The callback function to filter inside the array.
  * @return {number} The index of the property.
- */export var findIndex=function findIndex(arr,fn){if(Array.isArray(arr)){for(var i=0;i<arr.length;i+=1){if(fn(arr[i])){return i;}}}return-1;};/**
+ */
+export const findIndex = (arr, fn) => {
+  if (Array.isArray(arr)) {
+    for (let i = 0; i < arr.length; i += 1) {
+      if (fn(arr[i])) {
+        return i;
+      }
+    }
+  }
+  return -1;
+};
+
+/**
  * Convert binary data into hexadecimal representation
  * @param {string|number} str The string that shall be encoded
  * @see http://locutus.io/php/strings/bin2hex/
  * @return {string} The hexadecimal representation of the given string
- */export var bin2hex=function bin2hex(str){var s="".concat(str);var i;var l;var o='';var n;for(i=0,l=s.length;i<l;i+=1){n=s.charCodeAt(i).toString(16);o+=n.length<2?"0".concat(n):n;}return o;};/**
+ */
+export const bin2hex = str => {
+  const s = `${str}`;
+  let i;
+  let l;
+  let o = '';
+  let n;
+  for (i = 0, l = s.length; i < l; i += 1) {
+    n = s.charCodeAt(i).toString(16);
+    o += n.length < 2 ? `0${n}` : n;
+  }
+  return o;
+};
+
+/**
  * Decodes a hexadecimal encoded binary string
  * @param {string} str The string that shall be decoded
  * @see http://locutus.io/php/strings/hex2bin/
  * @returns {string|boolean} Hexadecimal representation of data. FALSE if decoding failed.
- */export var hex2bin=function hex2bin(str){var s="".concat(str);var ret=[];var i=0;var l;for(l=s.length;i<l;i+=2){var c=parseInt(s.substr(i,1),16);var k=parseInt(s.substr(i+1,1),16);if(Number.isNaN(c)||Number.isNaN(k)){return false;}// eslint-disable-next-line no-bitwise
-ret.push(c<<4|k);}// eslint-disable-next-line prefer-spread
-return String.fromCharCode.apply(String,ret);};/**
+ */
+export const hex2bin = str => {
+  const s = `${str}`;
+  const ret = [];
+  let i = 0;
+  let l;
+  for (l = s.length; i < l; i += 2) {
+    const c = parseInt(s.substr(i, 1), 16);
+    const k = parseInt(s.substr(i + 1, 1), 16);
+    if (Number.isNaN(c) || Number.isNaN(k)) {
+      return false;
+    }
+
+    // eslint-disable-next-line no-bitwise
+    ret.push(c << 4 | k);
+  }
+
+  // eslint-disable-next-line prefer-spread
+  return String.fromCharCode.apply(String, ret);
+};
+
+/**
  * Compares two strings of object keys for object sorting.
  * @param {string} a The first key.
  * @param {string} b The second key.
  * @return {number} The sort order.
- */var defaultKeySortFn=function defaultKeySortFn(a,b){return a.localeCompare(b);};/**
+ */
+const defaultKeySortFn = (a, b) => a.localeCompare(b);
+
+/**
  * Deep sorts an object by its keys.
  * @param {Object} src The object to sort.
  * @param {Function} [comparator=defaultKeySortFn] The sorting operator callback.
  * @return {Object} The sorted object.
- */export var sortObject=function sortObject(src){var comparator=arguments.length>1&&arguments[1]!==undefined?arguments[1]:defaultKeySortFn;if(Array.isArray(src)){return src.map(function(item){return sortObject(item,comparator);});}if(isObject(src)){return Object.keys(src).sort(comparator).reduce(function(obj,key){return _extends({},obj,_defineProperty({},key,sortObject(src[key],comparator)));},{});}return src;};/**
+ */
+export const sortObject = (src, comparator = defaultKeySortFn) => {
+  if (Array.isArray(src)) {
+    return src.map(item => sortObject(item, comparator));
+  }
+  if (isObject(src)) {
+    return Object.keys(src).sort(comparator).reduce((obj, key) => ({
+      ...obj,
+      [key]: sortObject(src[key], comparator)
+    }), {});
+  }
+  return src;
+};
+
+/**
  * Transforms widget display options to match pipeline specifications.
  * @param {string} displayOptions The display options as specified by the widget settings.
  * @returns {string} The transformed string compatible with the pipeline requests.
- */export var transformDisplayOptions=function transformDisplayOptions(displayOptions){switch(displayOptions){case'relevance_asc':case'relevance_desc':return'relevance';case'price_asc':return'priceAsc';case'price_desc':return'priceDesc';case'name_asc':return'nameAsc';case'name_desc':return'nameDesc';default:return displayOptions;}};/**
+ */
+export const transformDisplayOptions = displayOptions => {
+  switch (displayOptions) {
+    case 'relevance_asc':
+    case 'relevance_desc':
+      return 'relevance';
+    case 'price_asc':
+      return 'priceAsc';
+    case 'price_desc':
+      return 'priceDesc';
+    case 'name_asc':
+      return 'nameAsc';
+    case 'name_desc':
+      return 'nameDesc';
+    default:
+      return displayOptions;
+  }
+};
+
+/**
  * Validates all parameters. The selector will return null if one parameter is invalid.
  * @param {Function} selector The original selector.
  * @param {Object} [defaultResult] The result when the selector fails.
  * @return {Function}
- */export var validateSelectorParams=function validateSelectorParams(selector){var defaultResult=arguments.length>1&&arguments[1]!==undefined?arguments[1]:null;return function(){for(var _len=arguments.length,params=new Array(_len),_key=0;_key<_len;_key++){params[_key]=arguments[_key];}if(params.some(function(param){return param===null||typeof param==='undefined';})){return defaultResult;}return selector.apply(void 0,params);};};/**
+ */
+export const validateSelectorParams = (selector, defaultResult = null) => (...params) => {
+  if (params.some(param => param === null || typeof param === 'undefined')) {
+    return defaultResult;
+  }
+  return selector(...params);
+};
+
+/**
  * @callback ArrayItemComparator
  * @param {string} path
  * @param {*} prev
@@ -71,7 +205,8 @@ return String.fromCharCode.apply(String,ret);};/**
  * @param {number} prevIndex
  * @param {number} nextIndex
  * @returns {boolean}
- */ /**
+ */
+/**
  * Takes a destination object and a source and merges the source object into the destination.
  * Differing properties will replaced. References are kept where possible.
  * @param {Object} destination Object to mutate
@@ -79,15 +214,55 @@ return String.fromCharCode.apply(String,ret);};/**
  * @param {boolean} [warn] Enables log output on mismatching types. Defaults to 'true'.
  * @param {ArrayItemComparator|null} [arrayComparator] Defines how to compare array items.
  * @param {string} [path] Path that specifies the position of a given merge within the object tree.
- */export function assignObjectDeep(destination,source){var warn=arguments.length>2&&arguments[2]!==undefined?arguments[2]:true;var arrayComparator=arguments.length>3&&arguments[3]!==undefined?arguments[3]:null;var path=arguments.length>4&&arguments[4]!==undefined?arguments[4]:'';// Avoids eslint warning on param mutation, which is necessary
-var dest=destination;var src=source;// Don't do anything when types are scalar (can occur in recursion)
-if(_typeof(dest)!=='object'||_typeof(src)!=='object'){return;}Object.keys(src).forEach(function(key){var keyPath="".concat(path,".").concat(key).replace(/^\./,'');var prop=src[key];if(!isObjectOrArray(dest[key])||!isObjectOrArray(prop)){// output a warning if only one of both is an object (undefined dest is fine -> no warning)
-if(warn&&dest[key]!==undefined&&(!isObjectOrArray(dest[key])?isObjectOrArray(prop):!isObjectOrArray(prop))){logger.warn('Trying to merge object properties with mixed object types: ',prop,dest[key]);}// Overwrite always if one of the props is not an object or array
-dest[key]=prop;return;}// Both structures are objects but one or both can be an array
-if(isArray(prop)&&isArray(dest[key])){// Try to keep reference of as many array items as possible
-prop.forEach(function(element,destIndex){var itemPath="".concat(keyPath,".").concat(destIndex);// Check if a maching array item exists for merging
-var existing=dest[key].find(function(prev,prevIndex){return arrayComparator(itemPath,prev,element,prevIndex,destIndex);});// Merge into existing if found or add to array otherwise
-if(existing!==undefined){// Scalar types can't be merged and will be ignored when an equal exists
-assignObjectDeep(existing,element,warn,arrayComparator,itemPath);}else{dest[key].push(element);}});}else if(!isArray(prop)&&!isArray(dest[key])){// Merge objects
-assignObjectDeep(dest[key],prop,warn,arrayComparator,keyPath);}else{// Object types differ, print a warning
-if(warn){logger.warn('Merging object properties with mixed object types: ',prop,dest[key]);}dest[key]=prop;}});}
+ */
+export function assignObjectDeep(destination, source, warn = true, arrayComparator = null, path = '') {
+  // Avoids eslint warning on param mutation, which is necessary
+  const dest = destination;
+  const src = source;
+
+  // Don't do anything when types are scalar (can occur in recursion)
+  if (typeof dest !== 'object' || typeof src !== 'object') {
+    return;
+  }
+  Object.keys(src).forEach(key => {
+    const keyPath = `${path}.${key}`.replace(/^\./, '');
+    const prop = src[key];
+    if (!isObjectOrArray(dest[key]) || !isObjectOrArray(prop)) {
+      // output a warning if only one of both is an object (undefined dest is fine -> no warning)
+      if (warn && dest[key] !== undefined && (!isObjectOrArray(dest[key]) ? isObjectOrArray(prop) : !isObjectOrArray(prop))) {
+        logger.warn('Trying to merge object properties with mixed object types: ', prop, dest[key]);
+      }
+
+      // Overwrite always if one of the props is not an object or array
+      dest[key] = prop;
+      return;
+    }
+
+    // Both structures are objects but one or both can be an array
+    if (isArray(prop) && isArray(dest[key])) {
+      // Try to keep reference of as many array items as possible
+      prop.forEach((element, destIndex) => {
+        const itemPath = `${keyPath}.${destIndex}`;
+        // Check if a maching array item exists for merging
+        const existing = dest[key].find((prev, prevIndex) => arrayComparator(itemPath, prev, element, prevIndex, destIndex));
+
+        // Merge into existing if found or add to array otherwise
+        if (existing !== undefined) {
+          // Scalar types can't be merged and will be ignored when an equal exists
+          assignObjectDeep(existing, element, warn, arrayComparator, itemPath);
+        } else {
+          dest[key].push(element);
+        }
+      });
+    } else if (!isArray(prop) && !isArray(dest[key])) {
+      // Merge objects
+      assignObjectDeep(dest[key], prop, warn, arrayComparator, keyPath);
+    } else {
+      // Object types differ, print a warning
+      if (warn) {
+        logger.warn('Merging object properties with mixed object types: ', prop, dest[key]);
+      }
+      dest[key] = prop;
+    }
+  });
+}

package/helpers/data/spec.js

@@ -1,6 +1,100 @@
-import{assignObjectDeep}from'.';import{isObject}from"../validation";describe('helpers/data',function(){describe('assignObjectDeep',function(){it('should merge simple objects correctly',function(){var modifier={b:0,c:null,d:undefined,g:1.7,h:'g',i:{x:'x'},j:['a','b']};// Object to be mutated
-var actual={a:0,b:1,c:'abc',d:'def',e:'ghi',f:null,g:1.6};assignObjectDeep(actual,modifier,false);expect(actual).toEqual({a:0,b:0,c:null,d:undefined,e:'ghi',f:null,g:1.7,h:'g',i:{x:'x'},j:['a','b']});});it('should merge objects containing sub-objects correctly',function(){var modifier={a:{x:2,y:{i:'first mod',k:'new entry'}},b:'c',c:undefined,d:{x:'x'},e:['a','b']};// Object to be mutated
-var actual={a:{x:1,y:{i:'first',j:'second'}},b:{x:2,y:{i:'first',j:'second'}}};assignObjectDeep(actual,modifier,false);expect(actual).toEqual({a:{x:2,y:{i:'first mod',j:'second',k:'new entry'}},b:'c',c:undefined,d:{x:'x'},e:['a','b']});});it('should merge objects containing arrays correctly',function(){/**
+import { assignObjectDeep } from '.';
+import { isObject } from "../validation";
+describe('helpers/data', () => {
+  describe('assignObjectDeep', () => {
+    it('should merge simple objects correctly', () => {
+      const modifier = {
+        b: 0,
+        c: null,
+        d: undefined,
+        g: 1.7,
+        h: 'g',
+        i: {
+          x: 'x'
+        },
+        j: ['a', 'b']
+      };
+
+      // Object to be mutated
+      const actual = {
+        a: 0,
+        b: 1,
+        c: 'abc',
+        d: 'def',
+        e: 'ghi',
+        f: null,
+        g: 1.6
+      };
+      assignObjectDeep(actual, modifier, false);
+      expect(actual).toEqual({
+        a: 0,
+        b: 0,
+        c: null,
+        d: undefined,
+        e: 'ghi',
+        f: null,
+        g: 1.7,
+        h: 'g',
+        i: {
+          x: 'x'
+        },
+        j: ['a', 'b']
+      });
+    });
+    it('should merge objects containing sub-objects correctly', () => {
+      const modifier = {
+        a: {
+          x: 2,
+          y: {
+            i: 'first mod',
+            k: 'new entry'
+          }
+        },
+        b: 'c',
+        c: undefined,
+        d: {
+          x: 'x'
+        },
+        e: ['a', 'b']
+      };
+
+      // Object to be mutated
+      const actual = {
+        a: {
+          x: 1,
+          y: {
+            i: 'first',
+            j: 'second'
+          }
+        },
+        b: {
+          x: 2,
+          y: {
+            i: 'first',
+            j: 'second'
+          }
+        }
+      };
+      assignObjectDeep(actual, modifier, false);
+      expect(actual).toEqual({
+        a: {
+          x: 2,
+          y: {
+            i: 'first mod',
+            j: 'second',
+            k: 'new entry'
+          }
+        },
+        b: 'c',
+        c: undefined,
+        d: {
+          x: 'x'
+        },
+        e: ['a', 'b']
+      });
+    });
+    it('should merge objects containing arrays correctly', () => {
+      /**
        * This comparator detects unique scalar types and objects containing an id
        * within the 'a' prop
        *
@@ -8,7 +102,93 @@ var actual={a:{x:1,y:{i:'first',j:'second'}},b:{x:2,y:{i:'first',j:'second'}}};a
        * @param {*} prev prev
        * @param {*} next next
        * @returns {boolean}
-       */var comparator=function comparator(path,prev,next){// Scalar types
-if(!isObject(prev)||!isObject(next)){return prev===next;}// Object merge only occurring on array object-items within the 'a' prop
-if(path.startsWith('$.a.')){return prev.id===next.id;}return false;};var modifier={b:[1,2,3],a:[['non-unique1','non-unique1'],'unique element',2,{id:'custom-id-2',data:{x:null,y:{i:'first',j:'second mod',k:'third'},z:'new data entry'}},{id:'custom-id-3',data:{x:'a'}}]};// Object to be mutated
-var actual={a:[1,'unique element',{id:'custom-id-1',data:{x:1,y:{i:'first',j:'second'}}},{id:'custom-id-2',data:{x:1,y:{i:'first',j:'second'}}},['non-unique1','non-unique1']],b:[0]};assignObjectDeep(actual,modifier,false,comparator,'$');expect(actual).toEqual({a:[1,'unique element',{id:'custom-id-1',data:{x:1,y:{i:'first',j:'second'}}},{id:'custom-id-2',data:{x:null,y:{i:'first',j:'second mod',k:'third'},z:'new data entry'}},['non-unique1','non-unique1'],['non-unique1','non-unique1'],2,{id:'custom-id-3',data:{x:'a'}}],b:[0,1,2,3]});});});});
+       */
+      const comparator = (path, prev, next) => {
+        // Scalar types
+        if (!isObject(prev) || !isObject(next)) {
+          return prev === next;
+        }
+
+        // Object merge only occurring on array object-items within the 'a' prop
+        if (path.startsWith('$.a.')) {
+          return prev.id === next.id;
+        }
+        return false;
+      };
+      const modifier = {
+        b: [1, 2, 3],
+        a: [['non-unique1', 'non-unique1'], 'unique element', 2, {
+          id: 'custom-id-2',
+          data: {
+            x: null,
+            y: {
+              i: 'first',
+              j: 'second mod',
+              k: 'third'
+            },
+            z: 'new data entry'
+          }
+        }, {
+          id: 'custom-id-3',
+          data: {
+            x: 'a'
+          }
+        }]
+      };
+
+      // Object to be mutated
+      const actual = {
+        a: [1, 'unique element', {
+          id: 'custom-id-1',
+          data: {
+            x: 1,
+            y: {
+              i: 'first',
+              j: 'second'
+            }
+          }
+        }, {
+          id: 'custom-id-2',
+          data: {
+            x: 1,
+            y: {
+              i: 'first',
+              j: 'second'
+            }
+          }
+        }, ['non-unique1', 'non-unique1']],
+        b: [0]
+      };
+      assignObjectDeep(actual, modifier, false, comparator, '$');
+      expect(actual).toEqual({
+        a: [1, 'unique element', {
+          id: 'custom-id-1',
+          data: {
+            x: 1,
+            y: {
+              i: 'first',
+              j: 'second'
+            }
+          }
+        }, {
+          id: 'custom-id-2',
+          data: {
+            x: null,
+            y: {
+              i: 'first',
+              j: 'second mod',
+              k: 'third'
+            },
+            z: 'new data entry'
+          }
+        }, ['non-unique1', 'non-unique1'], ['non-unique1', 'non-unique1'], 2, {
+          id: 'custom-id-3',
+          data: {
+            x: 'a'
+          }
+        }],
+        b: [0, 1, 2, 3]
+      });
+    });
+  });
+});

package/helpers/date/index.js

@@ -1,28 +1,80 @@
 /**
  * @refactor install moment.js
- */var durationRegex=/^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;var durationModifiers={Year:function Year(date,unit){return date.setFullYear(date.getFullYear()+unit);},Month:function Month(date,unit){return date.setMonth(date.getMonth()+unit);},Week:function Week(date,unit){return date.setDate(date.getDate()+unit*7);},Day:function Day(date,unit){return date.setDate(date.getDate()+unit);},Hour:function Hour(date,unit){return date.setHours(date.getHours()+unit);},Minute:function Minute(date,unit){return date.setMinutes(date.getMinutes()+unit);},Second:function Second(date,unit){return date.setSeconds(date.getSeconds()+unit);}};/**
+ */
+const durationRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
+const durationModifiers = {
+  Year: (date, unit) => date.setFullYear(date.getFullYear() + unit),
+  Month: (date, unit) => date.setMonth(date.getMonth() + unit),
+  Week: (date, unit) => date.setDate(date.getDate() + unit * 7),
+  Day: (date, unit) => date.setDate(date.getDate() + unit),
+  Hour: (date, unit) => date.setHours(date.getHours() + unit),
+  Minute: (date, unit) => date.setMinutes(date.getMinutes() + unit),
+  Second: (date, unit) => date.setSeconds(date.getSeconds() + unit)
+};
+
+/**
  * Returns true if date exclusively before (<=).
  * @param {Date} date date object.
  * @param {Date} beforeDate comparison date.
  * @return {boolean}.
- */export var isBefore=function isBefore(date,beforeDate){return!!(beforeDate&&date<beforeDate);};/**
+ */
+export const isBefore = (date, beforeDate) => !!(beforeDate && date < beforeDate);
+
+/**
  * Returns true if date exclusively after (>=).
  * @param {Date} date date object.
  * @param {Date} afterDate comparison date.
  * @return {boolean}.
- */export var isAfter=function isAfter(date,afterDate){return!!(afterDate&&date>afterDate);};/**
+ */
+export const isAfter = (date, afterDate) => !!(afterDate && date > afterDate);
+
+/**
  * Returns true if date inclusively between (>= & <=).
  * @param {Date} date date object.
  * @param {Date} leftDate left bound.
  * @param {Date} rightDate right bound.
  * @return {boolean}.
- */export var isBetween=function isBetween(date,leftDate,rightDate){if(!rightDate){return false;}if(!leftDate&&rightDate){return isBefore(date,rightDate);}return date>=leftDate&&date<=rightDate;};/**
+ */
+export const isBetween = (date, leftDate, rightDate) => {
+  if (!rightDate) {
+    return false;
+  }
+  if (!leftDate && rightDate) {
+    return isBefore(date, rightDate);
+  }
+  return date >= leftDate && date <= rightDate;
+};
+
+/**
  * Parse duration
  * @param {string} duration ISO 8601 duration.
  * @return {Object}
- */export var parseDuration=function parseDuration(duration){var d=durationRegex.exec(duration)||[];var fr=d[1]==='-'?-1:1;return{Year:d[2]&&(d[2]>0?d[2]*fr:d[2]),Month:d[3]&&(d[3]>0?d[3]*fr:d[3]),Week:d[4]&&(d[4]>0?d[4]*fr:d[4]),Day:d[5]&&(d[5]>0?d[5]*fr:d[5]),Hour:d[6]&&(d[6]>0?d[6]*fr:d[6]),Minute:d[7]&&(d[7]>0?d[7]*fr:d[7]),Second:d[8]&&(d[8]>0?d[8]*fr:d[8])};};/**
+ */
+export const parseDuration = duration => {
+  const d = durationRegex.exec(duration) || [];
+  const fr = d[1] === '-' ? -1 : 1;
+  return {
+    Year: d[2] && (d[2] > 0 ? d[2] * fr : d[2]),
+    Month: d[3] && (d[3] > 0 ? d[3] * fr : d[3]),
+    Week: d[4] && (d[4] > 0 ? d[4] * fr : d[4]),
+    Day: d[5] && (d[5] > 0 ? d[5] * fr : d[5]),
+    Hour: d[6] && (d[6] > 0 ? d[6] * fr : d[6]),
+    Minute: d[7] && (d[7] > 0 ? d[7] * fr : d[7]),
+    Second: d[8] && (d[8] > 0 ? d[8] * fr : d[8])
+  };
+};
+
+/**
  * Add duration to given date
  * @param {Date} date date object.
  * @param {string} duration ISO 8601 duration.
  * @return {void}
- */export var addDuration=function addDuration(date,duration){var parsed=parseDuration(duration);Object.keys(parsed).forEach(function(k){if(parsed[k]){durationModifiers[k](date,parsed[k]);}});};
+ */
+export const addDuration = (date, duration) => {
+  const parsed = parseDuration(duration);
+  Object.keys(parsed).forEach(k => {
+    if (parsed[k]) {
+      durationModifiers[k](date, parsed[k]);
+    }
+  });
+};