@bigbinary/neeto-commons-frontend 2.0.1 → 2.0.4

package/utils.js

@@ -1,21 +1,9 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var axios = require('axios');
-var ramda = require('ramda');
-var i18next = require('i18next');
-var dayjs = require('dayjs');
-var relativeTime = require('dayjs/plugin/relativeTime');
-var updateLocale = require('dayjs/plugin/updateLocale');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
-var i18next__default = /*#__PURE__*/_interopDefaultLegacy(i18next);
-var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
-var relativeTime__default = /*#__PURE__*/_interopDefaultLegacy(relativeTime);
-var updateLocale__default = /*#__PURE__*/_interopDefaultLegacy(updateLocale);
+import axios from 'axios';
+import { values, complement, isNil, isEmpty, curry, equals, toPairs, omit } from 'ramda';
+import i18next from 'i18next';
+import dayjs from 'dayjs';
+import relativeTime from 'dayjs/plugin/relativeTime';
+import updateLocale from 'dayjs/plugin/updateLocale';
 
 var HEADERS_KEYS = {
   xAuthEmail: "X-Auth-Email",
@@ -24,11 +12,72 @@ var HEADERS_KEYS = {
 };
 
 var resetAuthTokens = function resetAuthTokens() {
-  ramda.values(HEADERS_KEYS).forEach(function (header) {
-    delete axios__default["default"].defaults.headers[header];
+  values(HEADERS_KEYS).forEach(function (header) {
+    delete axios.defaults.headers[header];
   });
 };
 
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+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 _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 _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 _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 _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
     var info = gen[key](arg);
@@ -484,17 +533,637 @@ var getRandomInt = function getRandomInt() {
 
   return Math.floor(Math.random() * (b - a) + a);
 };
-ramda.complement(ramda.isNil);
-ramda.complement(ramda.isEmpty);
-ramda.curry(function (x, y) {
+complement(isNil);
+complement(isEmpty);
+curry(function (x, y) {
   return x !== y;
 });
-ramda.complement(ramda.equals);
+complement(equals);
+
+var queryString = {};
+
+var strictUriEncode = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+
+var token = '%[a-f0-9]{2}';
+var singleMatcher = new RegExp(token, 'gi');
+var multiMatcher = new RegExp('(' + token + ')+', 'gi');
+
+function decodeComponents(components, split) {
+	try {
+		// Try to decode the entire string first
+		return decodeURIComponent(components.join(''));
+	} catch (err) {
+		// Do nothing
+	}
+
+	if (components.length === 1) {
+		return components;
+	}
+
+	split = split || 1;
+
+	// Split the array in 2 parts
+	var left = components.slice(0, split);
+	var right = components.slice(split);
+
+	return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+
+function decode(input) {
+	try {
+		return decodeURIComponent(input);
+	} catch (err) {
+		var tokens = input.match(singleMatcher);
+
+		for (var i = 1; i < tokens.length; i++) {
+			input = decodeComponents(tokens, i).join('');
+
+			tokens = input.match(singleMatcher);
+		}
+
+		return input;
+	}
+}
+
+function customDecodeURIComponent(input) {
+	// Keep track of all the replacements and prefill the map with the `BOM`
+	var replaceMap = {
+		'%FE%FF': '\uFFFD\uFFFD',
+		'%FF%FE': '\uFFFD\uFFFD'
+	};
+
+	var match = multiMatcher.exec(input);
+	while (match) {
+		try {
+			// Decode as big chunks as possible
+			replaceMap[match[0]] = decodeURIComponent(match[0]);
+		} catch (err) {
+			var result = decode(match[0]);
+
+			if (result !== match[0]) {
+				replaceMap[match[0]] = result;
+			}
+		}
+
+		match = multiMatcher.exec(input);
+	}
+
+	// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
+	replaceMap['%C2'] = '\uFFFD';
+
+	var entries = Object.keys(replaceMap);
+
+	for (var i = 0; i < entries.length; i++) {
+		// Replace all decoded components
+		var key = entries[i];
+		input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
+	}
+
+	return input;
+}
+
+var decodeUriComponent = function (encodedURI) {
+	if (typeof encodedURI !== 'string') {
+		throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
+	}
+
+	try {
+		encodedURI = encodedURI.replace(/\+/g, ' ');
+
+		// Try the built in decoder first
+		return decodeURIComponent(encodedURI);
+	} catch (err) {
+		// Fallback to a more advanced decoder
+		return customDecodeURIComponent(encodedURI);
+	}
+};
+
+var splitOnFirst = (string, separator) => {
+	if (!(typeof string === 'string' && typeof separator === 'string')) {
+		throw new TypeError('Expected the arguments to be of type `string`');
+	}
+
+	if (separator === '') {
+		return [string];
+	}
+
+	const separatorIndex = string.indexOf(separator);
+
+	if (separatorIndex === -1) {
+		return [string];
+	}
+
+	return [
+		string.slice(0, separatorIndex),
+		string.slice(separatorIndex + separator.length)
+	];
+};
+
+var filterObj = function (obj, predicate) {
+	var ret = {};
+	var keys = Object.keys(obj);
+	var isArr = Array.isArray(predicate);
+
+	for (var i = 0; i < keys.length; i++) {
+		var key = keys[i];
+		var val = obj[key];
+
+		if (isArr ? predicate.indexOf(key) !== -1 : predicate(key, val, obj)) {
+			ret[key] = val;
+		}
+	}
+
+	return ret;
+};
+
+(function (exports) {
+	const strictUriEncode$1 = strictUriEncode;
+	const decodeComponent = decodeUriComponent;
+	const splitOnFirst$1 = splitOnFirst;
+	const filterObject = filterObj;
+
+	const isNullOrUndefined = value => value === null || value === undefined;
+
+	const encodeFragmentIdentifier = Symbol('encodeFragmentIdentifier');
+
+	function encoderForArrayFormat(options) {
+		switch (options.arrayFormat) {
+			case 'index':
+				return key => (result, value) => {
+					const index = result.length;
+
+					if (
+						value === undefined ||
+						(options.skipNull && value === null) ||
+						(options.skipEmptyString && value === '')
+					) {
+						return result;
+					}
+
+					if (value === null) {
+						return [...result, [encode(key, options), '[', index, ']'].join('')];
+					}
+
+					return [
+						...result,
+						[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')
+					];
+				};
+
+			case 'bracket':
+				return key => (result, value) => {
+					if (
+						value === undefined ||
+						(options.skipNull && value === null) ||
+						(options.skipEmptyString && value === '')
+					) {
+						return result;
+					}
+
+					if (value === null) {
+						return [...result, [encode(key, options), '[]'].join('')];
+					}
+
+					return [...result, [encode(key, options), '[]=', encode(value, options)].join('')];
+				};
+
+			case 'colon-list-separator':
+				return key => (result, value) => {
+					if (
+						value === undefined ||
+						(options.skipNull && value === null) ||
+						(options.skipEmptyString && value === '')
+					) {
+						return result;
+					}
+
+					if (value === null) {
+						return [...result, [encode(key, options), ':list='].join('')];
+					}
+
+					return [...result, [encode(key, options), ':list=', encode(value, options)].join('')];
+				};
+
+			case 'comma':
+			case 'separator':
+			case 'bracket-separator': {
+				const keyValueSep = options.arrayFormat === 'bracket-separator' ?
+					'[]=' :
+					'=';
+
+				return key => (result, value) => {
+					if (
+						value === undefined ||
+						(options.skipNull && value === null) ||
+						(options.skipEmptyString && value === '')
+					) {
+						return result;
+					}
+
+					// Translate null to an empty string so that it doesn't serialize as 'null'
+					value = value === null ? '' : value;
+
+					if (result.length === 0) {
+						return [[encode(key, options), keyValueSep, encode(value, options)].join('')];
+					}
+
+					return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
+				};
+			}
+
+			default:
+				return key => (result, value) => {
+					if (
+						value === undefined ||
+						(options.skipNull && value === null) ||
+						(options.skipEmptyString && value === '')
+					) {
+						return result;
+					}
+
+					if (value === null) {
+						return [...result, encode(key, options)];
+					}
+
+					return [...result, [encode(key, options), '=', encode(value, options)].join('')];
+				};
+		}
+	}
+
+	function parserForArrayFormat(options) {
+		let result;
+
+		switch (options.arrayFormat) {
+			case 'index':
+				return (key, value, accumulator) => {
+					result = /\[(\d*)\]$/.exec(key);
+
+					key = key.replace(/\[\d*\]$/, '');
+
+					if (!result) {
+						accumulator[key] = value;
+						return;
+					}
+
+					if (accumulator[key] === undefined) {
+						accumulator[key] = {};
+					}
+
+					accumulator[key][result[1]] = value;
+				};
+
+			case 'bracket':
+				return (key, value, accumulator) => {
+					result = /(\[\])$/.exec(key);
+					key = key.replace(/\[\]$/, '');
+
+					if (!result) {
+						accumulator[key] = value;
+						return;
+					}
+
+					if (accumulator[key] === undefined) {
+						accumulator[key] = [value];
+						return;
+					}
+
+					accumulator[key] = [].concat(accumulator[key], value);
+				};
+
+			case 'colon-list-separator':
+				return (key, value, accumulator) => {
+					result = /(:list)$/.exec(key);
+					key = key.replace(/:list$/, '');
+
+					if (!result) {
+						accumulator[key] = value;
+						return;
+					}
+
+					if (accumulator[key] === undefined) {
+						accumulator[key] = [value];
+						return;
+					}
+
+					accumulator[key] = [].concat(accumulator[key], value);
+				};
+
+			case 'comma':
+			case 'separator':
+				return (key, value, accumulator) => {
+					const isArray = typeof value === 'string' && value.includes(options.arrayFormatSeparator);
+					const isEncodedArray = (typeof value === 'string' && !isArray && decode(value, options).includes(options.arrayFormatSeparator));
+					value = isEncodedArray ? decode(value, options) : value;
+					const newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map(item => decode(item, options)) : value === null ? value : decode(value, options);
+					accumulator[key] = newValue;
+				};
+
+			case 'bracket-separator':
+				return (key, value, accumulator) => {
+					const isArray = /(\[\])$/.test(key);
+					key = key.replace(/\[\]$/, '');
+
+					if (!isArray) {
+						accumulator[key] = value ? decode(value, options) : value;
+						return;
+					}
+
+					const arrayValue = value === null ?
+						[] :
+						value.split(options.arrayFormatSeparator).map(item => decode(item, options));
+
+					if (accumulator[key] === undefined) {
+						accumulator[key] = arrayValue;
+						return;
+					}
+
+					accumulator[key] = [].concat(accumulator[key], arrayValue);
+				};
+
+			default:
+				return (key, value, accumulator) => {
+					if (accumulator[key] === undefined) {
+						accumulator[key] = value;
+						return;
+					}
+
+					accumulator[key] = [].concat(accumulator[key], value);
+				};
+		}
+	}
+
+	function validateArrayFormatSeparator(value) {
+		if (typeof value !== 'string' || value.length !== 1) {
+			throw new TypeError('arrayFormatSeparator must be single character string');
+		}
+	}
+
+	function encode(value, options) {
+		if (options.encode) {
+			return options.strict ? strictUriEncode$1(value) : encodeURIComponent(value);
+		}
+
+		return value;
+	}
+
+	function decode(value, options) {
+		if (options.decode) {
+			return decodeComponent(value);
+		}
+
+		return value;
+	}
+
+	function keysSorter(input) {
+		if (Array.isArray(input)) {
+			return input.sort();
+		}
+
+		if (typeof input === 'object') {
+			return keysSorter(Object.keys(input))
+				.sort((a, b) => Number(a) - Number(b))
+				.map(key => input[key]);
+		}
+
+		return input;
+	}
+
+	function removeHash(input) {
+		const hashStart = input.indexOf('#');
+		if (hashStart !== -1) {
+			input = input.slice(0, hashStart);
+		}
+
+		return input;
+	}
+
+	function getHash(url) {
+		let hash = '';
+		const hashStart = url.indexOf('#');
+		if (hashStart !== -1) {
+			hash = url.slice(hashStart);
+		}
+
+		return hash;
+	}
+
+	function extract(input) {
+		input = removeHash(input);
+		const queryStart = input.indexOf('?');
+		if (queryStart === -1) {
+			return '';
+		}
+
+		return input.slice(queryStart + 1);
+	}
+
+	function parseValue(value, options) {
+		if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {
+			value = Number(value);
+		} else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
+			value = value.toLowerCase() === 'true';
+		}
+
+		return value;
+	}
+
+	function parse(query, options) {
+		options = Object.assign({
+			decode: true,
+			sort: true,
+			arrayFormat: 'none',
+			arrayFormatSeparator: ',',
+			parseNumbers: false,
+			parseBooleans: false
+		}, options);
+
+		validateArrayFormatSeparator(options.arrayFormatSeparator);
+
+		const formatter = parserForArrayFormat(options);
+
+		// Create an object with no prototype
+		const ret = Object.create(null);
+
+		if (typeof query !== 'string') {
+			return ret;
+		}
+
+		query = query.trim().replace(/^[?#&]/, '');
+
+		if (!query) {
+			return ret;
+		}
+
+		for (const param of query.split('&')) {
+			if (param === '') {
+				continue;
+			}
+
+			let [key, value] = splitOnFirst$1(options.decode ? param.replace(/\+/g, ' ') : param, '=');
+
+			// Missing `=` should be `null`:
+			// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
+			value = value === undefined ? null : ['comma', 'separator', 'bracket-separator'].includes(options.arrayFormat) ? value : decode(value, options);
+			formatter(decode(key, options), value, ret);
+		}
+
+		for (const key of Object.keys(ret)) {
+			const value = ret[key];
+			if (typeof value === 'object' && value !== null) {
+				for (const k of Object.keys(value)) {
+					value[k] = parseValue(value[k], options);
+				}
+			} else {
+				ret[key] = parseValue(value, options);
+			}
+		}
+
+		if (options.sort === false) {
+			return ret;
+		}
+
+		return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
+			const value = ret[key];
+			if (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {
+				// Sort object keys, not values
+				result[key] = keysSorter(value);
+			} else {
+				result[key] = value;
+			}
+
+			return result;
+		}, Object.create(null));
+	}
+
+	exports.extract = extract;
+	exports.parse = parse;
+
+	exports.stringify = (object, options) => {
+		if (!object) {
+			return '';
+		}
+
+		options = Object.assign({
+			encode: true,
+			strict: true,
+			arrayFormat: 'none',
+			arrayFormatSeparator: ','
+		}, options);
+
+		validateArrayFormatSeparator(options.arrayFormatSeparator);
+
+		const shouldFilter = key => (
+			(options.skipNull && isNullOrUndefined(object[key])) ||
+			(options.skipEmptyString && object[key] === '')
+		);
+
+		const formatter = encoderForArrayFormat(options);
+
+		const objectCopy = {};
+
+		for (const key of Object.keys(object)) {
+			if (!shouldFilter(key)) {
+				objectCopy[key] = object[key];
+			}
+		}
+
+		const keys = Object.keys(objectCopy);
+
+		if (options.sort !== false) {
+			keys.sort(options.sort);
+		}
+
+		return keys.map(key => {
+			const value = object[key];
+
+			if (value === undefined) {
+				return '';
+			}
+
+			if (value === null) {
+				return encode(key, options);
+			}
+
+			if (Array.isArray(value)) {
+				if (value.length === 0 && options.arrayFormat === 'bracket-separator') {
+					return encode(key, options) + '[]';
+				}
+
+				return value
+					.reduce(formatter(key), [])
+					.join('&');
+			}
+
+			return encode(key, options) + '=' + encode(value, options);
+		}).filter(x => x.length > 0).join('&');
+	};
+
+	exports.parseUrl = (url, options) => {
+		options = Object.assign({
+			decode: true
+		}, options);
+
+		const [url_, hash] = splitOnFirst$1(url, '#');
+
+		return Object.assign(
+			{
+				url: url_.split('?')[0] || '',
+				query: parse(extract(url), options)
+			},
+			options && options.parseFragmentIdentifier && hash ? {fragmentIdentifier: decode(hash, options)} : {}
+		);
+	};
+
+	exports.stringifyUrl = (object, options) => {
+		options = Object.assign({
+			encode: true,
+			strict: true,
+			[encodeFragmentIdentifier]: true
+		}, options);
+
+		const url = removeHash(object.url).split('?')[0] || '';
+		const queryFromUrl = exports.extract(object.url);
+		const parsedQueryFromUrl = exports.parse(queryFromUrl, {sort: false});
+
+		const query = Object.assign(parsedQueryFromUrl, object.query);
+		let queryString = exports.stringify(query, options);
+		if (queryString) {
+			queryString = `?${queryString}`;
+		}
+
+		let hash = getHash(object.url);
+		if (object.fragmentIdentifier) {
+			hash = `#${options[encodeFragmentIdentifier] ? encode(object.fragmentIdentifier, options) : object.fragmentIdentifier}`;
+		}
+
+		return `${url}${queryString}${hash}`;
+	};
+
+	exports.pick = (input, filter, options) => {
+		options = Object.assign({
+			parseFragmentIdentifier: true,
+			[encodeFragmentIdentifier]: false
+		}, options);
+
+		const {url, query, fragmentIdentifier} = exports.parseUrl(input, options);
+		return exports.stringifyUrl({
+			url,
+			query: filterObject(query, filter),
+			fragmentIdentifier
+		}, options);
+	};
+
+	exports.exclude = (input, filter, options) => {
+		const exclusionFilter = Array.isArray(filter) ? key => !filter.includes(key) : (key, value) => !filter(key, value);
+
+		return exports.pick(input, exclusionFilter, options);
+	};
+} (queryString));
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var withEventTargetValue = ramda.curry(function (func, event) {
+var withEventTargetValue = curry(function (func, event) {
   return func(event.target.value);
 });
 var getSubdomain = function getSubdomain() {
@@ -509,7 +1178,7 @@ var simulateApiCall = function simulateApiCall(result, error) {
     return setTimeout(function () {
       var defaultErrorObj = {
         success: false,
-        notice: i18next__default["default"].t("neetoCommons.notice.errorOccurred")
+        notice: i18next.t("neetoCommons.notice.errorOccurred")
       };
       Math.random() < errorProbability ? reject(_objectSpread(_objectSpread({}, defaultErrorObj), error)) : resolve(result);
     }, delay);
@@ -531,7 +1200,7 @@ var copyToClipboard = /*#__PURE__*/function () {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            _ref2 = _args.length > 1 && _args[1] !== undefined ? _args[1] : {}, _ref2$showToastr = _ref2.showToastr, showToastr = _ref2$showToastr === void 0 ? true : _ref2$showToastr, _ref2$message = _ref2.message, message = _ref2$message === void 0 ? i18next__default["default"].t("neetoCommons.toastr.success.copiedToClipboard") : _ref2$message;
+            _ref2 = _args.length > 1 && _args[1] !== undefined ? _args[1] : {}, _ref2$showToastr = _ref2.showToastr, showToastr = _ref2$showToastr === void 0 ? true : _ref2$showToastr, _ref2$message = _ref2.message, message = _ref2$message === void 0 ? i18next.t("neetoCommons.toastr.success.copiedToClipboard") : _ref2$message;
 
             /*
               This is a workaround to prevent the jest tests from failing. Once the issue in neetoUI
@@ -586,40 +1255,52 @@ var copyToClipboard = /*#__PURE__*/function () {
     return _ref.apply(this, arguments);
   };
 }();
+var buildUrl = function buildUrl(route, params) {
+  var placeHolders = [];
+  toPairs(params).forEach(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+        key = _ref4[0],
+        value = _ref4[1];
+
+    if (route.includes(":".concat(key))) {
+      placeHolders.push(key);
+      route = route.replace(":".concat(key), encodeURIComponent(value));
+    }
+  });
+  var queryParams = omit(placeHolders, params);
+  return isEmpty(queryParams) ? route : "".concat(route, "?").concat(queryString.stringify(queryParams));
+};
 
-dayjs__default["default"].extend(relativeTime__default["default"]);
-dayjs__default["default"].extend(updateLocale__default["default"]);
+dayjs.extend(relativeTime);
+dayjs.extend(updateLocale);
 var timeFormat = {
   fromNow: function fromNow(time) {
-    return dayjs__default["default"](time).fromNow();
+    return dayjs(time).fromNow();
   },
   time: function time(_time) {
-    return dayjs__default["default"](_time).format("h:mm A");
+    return dayjs(_time).format("h:mm A");
   },
   date: function date(time) {
-    return dayjs__default["default"](time).format("MMM D, YYYY");
+    return dayjs(time).format("MMM D, YYYY");
   },
   dateWeek: function dateWeek(time) {
-    return dayjs__default["default"](time).format("MMM D, YYYY ddd");
+    return dayjs(time).format("MMM D, YYYY ddd");
+  },
+  dateWeekWithoutYear: function dateWeekWithoutYear(time) {
+    return dayjs(time).format("MMM D, ddd");
   },
   dateTime: function dateTime(time) {
-    return dayjs__default["default"](time).format("MMM D, YYYY h:mm A");
+    return dayjs(time).format("MMM D, YYYY h:mm A");
   },
   dateWeekTime: function dateWeekTime(time) {
-    return dayjs__default["default"](time).format("MMM D, YYYY ddd h:mm A");
+    return dayjs(time).format("MMM D, YYYY ddd h:mm A");
   },
   extended: function extended(time) {
-    var dateTime = dayjs__default["default"](time).format("dddd MMMM D, YYYY h:mm A");
-    var fromNow = dayjs__default["default"](time).fromNow();
+    var dateTime = dayjs(time).format("dddd MMMM D, YYYY h:mm A");
+    var fromNow = dayjs(time).fromNow();
     return "".concat(dateTime, " (").concat(fromNow, ")");
   }
 };
 var dateFormat = timeFormat;
 
-exports.copyToClipboard = copyToClipboard;
-exports.dateFormat = dateFormat;
-exports.getSubdomain = getSubdomain;
-exports.resetAuthTokens = resetAuthTokens;
-exports.simulateApiCall = simulateApiCall;
-exports.timeFormat = timeFormat;
-exports.withEventTargetValue = withEventTargetValue;
+export { buildUrl, copyToClipboard, dateFormat, getSubdomain, resetAuthTokens, simulateApiCall, timeFormat, withEventTargetValue };