@scaleflex/widget-utils 4.4.0 → 4.5.0

package/lib/fieldsQueriesGetters.js

@@ -0,0 +1,46 @@
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import getDateRange from './Timeframes/getDateRange';
+import { FILTER_CONDITIONS } from './constants';
+import isNumber from './isNumber';
+import literalDateFromDateObj from './literalDateFromDateObj';
+export var getFieldValueQuery = function getFieldValueQuery(metadataFilter, value) {
+  var key = metadataFilter.key,
+    _metadataFilter$condi = metadataFilter.condition,
+    condition = _metadataFilter$condi === void 0 ? FILTER_CONDITIONS.IS : _metadataFilter$condi,
+    _metadataFilter$opera = metadataFilter.operator,
+    operator = _metadataFilter$opera === void 0 ? ':' : _metadataFilter$opera;
+  var conditionPrefix = condition === FILTER_CONDITIONS.IS_NOT ? '-' : '';
+  return "".concat(key).concat(operator).concat(conditionPrefix).concat(value);
+};
+export var getDateFieldQuery = function getDateFieldQuery(metadataFilter) {
+  var value = metadataFilter.value;
+  var query = isNumber(value) ? getDateRange(value, literalDateFromDateObj, value > -1) : value;
+  if (Array.isArray(query)) {
+    query = _toConsumableArray(query);
+    if (isNumber(query[0])) {
+      query[0] = getDateRange(query[0], literalDateFromDateObj, query[0] > -1);
+    }
+    if (isNumber(query[1])) {
+      query[1] = getDateRange(query[1], literalDateFromDateObj, query[1] > -1);
+    }
+    if (query.length === 2) {
+      query = "".concat(query[0] || '', "..").concat(query[1] || '');
+    }
+  }
+  return "\"".concat(getFieldValueQuery(metadataFilter, query), "\"");
+};
+export var getTextFieldQuery = function getTextFieldQuery(metadataFilter) {
+  var key = metadataFilter.key,
+    value = metadataFilter.value,
+    _metadataFilter$condi2 = metadataFilter.condition,
+    condition = _metadataFilter$condi2 === void 0 ? FILTER_CONDITIONS.IS : _metadataFilter$condi2;
+  if (condition === FILTER_CONDITIONS.IS) {
+    return "".concat(key, ":\"").concat(value, "\"");
+  }
+  return "".concat(key, "~\"").concat(value, "\"");
+};

package/lib/findAllDOMElements.js

@@ -0,0 +1,18 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import isDOMElement from './isDOMElement';
+
+/**
+ * Find one or more DOM elements.
+ *
+ * @param {string} element
+ * @returns {Array|null}
+ */
+export default function findAllDOMElements(element) {
+  if (typeof element === 'string') {
+    var elements = [].slice.call(document.querySelectorAll(element));
+    return elements.length > 0 ? elements : null;
+  }
+  if (_typeof(element) === 'object' && isDOMElement(element)) {
+    return [element];
+  }
+}

package/lib/findAllRegexMatchesInString.js

@@ -0,0 +1,16 @@
+var findAllRegexMatchesInString = function findAllRegexMatchesInString() {
+  var str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var regex = arguments.length > 1 ? arguments[1] : undefined;
+  var output = [];
+  var tmpResult;
+  // eslint-disable-next-line no-cond-assign
+  while ((tmpResult = regex.exec(str)) !== null) {
+    output.push({
+      startIndex: tmpResult.index,
+      endIndex: regex.lastIndex,
+      match: tmpResult[0]
+    });
+  }
+  return output;
+};
+export default findAllRegexMatchesInString;

package/lib/findDOMElement.js

@@ -0,0 +1,17 @@
+import isDOMElement from './isDOMElement';
+
+/**
+ * Find a DOM element.
+ *
+ * @param {Node|string} element
+ * @returns {Node|null}
+ */
+export default function findDOMElement(element) {
+  var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document;
+  if (typeof element === 'string') {
+    return context.querySelector(element);
+  }
+  if (isDOMElement(element)) {
+    return element;
+  }
+}

package/lib/findIndex.js

@@ -0,0 +1,9 @@
+/**
+ * Array.prototype.findIndex ponyfill for old browsers.
+ */
+export default function findIndex(array, predicate) {
+  for (var i = 0; i < array.length; i++) {
+    if (predicate(array[i])) return i;
+  }
+  return -1;
+}

package/lib/formatDuration.js

@@ -0,0 +1,22 @@
+/**
+ * Formats duration from 02:25:33 to 2h 25m 33s (separator is configurable, so possible to convert 02.33.44)
+ *
+ * @returns {string}
+ *
+ * @param {string|number} duration -- Duration as string or number
+ * @param {Function} i18n -- The translation function for translating the shown confirmation message - eg. plugin.i18n
+ * @param {string} separator -- The separator is used between time parts
+ */
+export default (function (duration) {
+  var i18n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  var separator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ':';
+  var DURATION_LABELS = [i18n('durationSeconds', 's'), i18n('durationMinutes', 'm'), i18n('durationHours', 'h')];
+  var durationArray = duration.toString().split(separator).reverse();
+  return durationArray.map(function (part) {
+    return Number(part);
+  }).map(function () {
+    var part = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    var index = arguments.length > 1 ? arguments[1] : undefined;
+    return part > 0 ? "".concat(part).concat(DURATION_LABELS[index]) : '';
+  }).reverse().join(' ');
+});

package/lib/formatNumbers.js

@@ -0,0 +1,32 @@
+export var convertToLocaleNumber = function convertToLocaleNumber(value, language) {
+  if (!language || value !== 0 && !value) return value;
+  try {
+    var _value$toString$trim;
+    var splitValue = (_value$toString$trim = value.toString().trim()) === null || _value$toString$trim === void 0 ? void 0 : _value$toString$trim.match(/[a-z]+|[^a-z]+/gi);
+    var formattedValue = splitValue.map(function (val) {
+      return isNaN(val) ? val : new Intl.NumberFormat(language, {
+        maximumFractionDigits: 20
+      }).format(val);
+    });
+    return formattedValue.join(' ');
+  } catch (e) {
+    return value;
+  }
+};
+export var toInitialNumber = function toInitialNumber(value) {
+  var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '.';
+  if (!value) {
+    return value;
+  }
+  return ((value === null || value === void 0 ? void 0 : value.toString()) || '').replace(new RegExp("[^0-9".concat(separator, "]"), 'g'), '').replace(',', '.');
+};
+export var getLocaleNumberSeparator = function getLocaleNumberSeparator() {
+  var language = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'en-US';
+  var separator;
+  try {
+    separator = new Intl.NumberFormat(language).format('0.1') === '0.1' ? '.' : ',';
+  } catch (e) {
+    separator = '';
+  }
+  return separator;
+};

package/lib/formatResolution.js

@@ -0,0 +1,17 @@
+/**
+ * Formats resolution from 1200x800 to 1200 x 800 px
+ *
+ * @returns {string}
+ *
+ * @param {string} resolution -- Resolution as string
+ * @param {string} separator -- Separator that should be replaced
+ * @param {string} newSeparator -- Separator that should be placed
+ * @param {boolean} addPx -- Either add px at the end or not
+ */
+export default (function () {
+  var resolution = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'x';
+  var newSeparator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'x';
+  var addPx = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  return resolution.replace(separator, " ".concat(newSeparator, " ")) + (addPx ? ' px' : '');
+});

package/lib/formatSeconds.js

@@ -0,0 +1,14 @@
+/**
+ * Takes an Integer value of seconds (e.g. 83) and converts it into a human-readable formatted string (e.g. '1:10:23').
+ *
+ * @param {Integer} seconds
+ * @returns {string} the formatted seconds (e.g. '1:10:23' for 1 hour, 10 minutes and 23 seconds)
+ *
+ */
+export default function formatSeconds(seconds) {
+  if (!seconds) return;
+  var formattedHours = Math.floor(seconds / 3600);
+  var formattedMinutes = Math.floor(seconds % 3600 / 60);
+  var formattedSeconds = Math.floor(seconds % 3600 % 60);
+  return "".concat(formattedHours ? "".concat(formattedHours, ":") : '').concat(String(formattedMinutes).padStart(2, 0), ":").concat(String(Math.floor(formattedSeconds % 60)).padStart(2, 0));
+}

package/lib/generateFileId.js

@@ -0,0 +1,53 @@
+/**
+ * Takes a file object and turns it into fileID, by converting file.name to lowercase,
+ * removing extra characters and adding type, size and lastModified
+ *
+ * @param {object} file
+ * @returns {string} the fileID
+ */
+export default function generateFileId(file) {
+  // It's tempting to do `[items].filter(Boolean).join('-')` here, but that
+  // is slower! simple string concatenation is fast
+
+  var id = 'filerobot';
+  if (typeof file.name === 'string') {
+    id += '-' + encodeFilename(file.name.toLowerCase());
+  }
+  if (file.toFolder !== undefined) {
+    id += '-' + encodeFilename(file.toFolder.toLowerCase());
+  }
+  if (file.type !== undefined) {
+    id += '-' + file.type;
+  }
+  if (file.data) {
+    if (typeof file.data.relativePath === 'string') {
+      id += '-' + encodeFilename(file.data.relativePath.toLowerCase());
+    }
+
+    /**
+     * TODO: check the following comment after the commiting time,
+     * Removed the data size, and last modified, to make the id unified for the files
+     * so if a new version is being uploaded we will override the base on in the progress panel's activities if there
+     * If no issues reported about progress panel/activities related to this comment after some time, please remove it and improve the wrapper condition.
+     * related to this task: https://scaleflexhq.atlassian.net/browse/FRA-7291
+    */
+
+    // if (file.data.size !== undefined) {
+    //   id += '-' + file.data.size
+    // }
+    // if (file.data.lastModified !== undefined) {
+    //   id += '-' + file.data.lastModified
+    // }
+  }
+  return id;
+}
+function encodeFilename(name) {
+  var suffix = '';
+  return name.replace(/[^A-Z0-9]/ig, function (character) {
+    suffix += '-' + encodeCharacter(character);
+    return '/';
+  }) + suffix;
+}
+function encodeCharacter(character) {
+  return character.charCodeAt(0).toString(32);
+}

package/lib/generateI18nKeyFromString.js

@@ -0,0 +1,11 @@
+import capitalizeFirstLetter from './capitalizeFirstLetter';
+import lowercaseFirstLetter from './lowercaseFirstLetter';
+export default (function () {
+  var str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  if (typeof str === 'string') {
+    return str.split(' ').filter(Boolean).map(function (item, index) {
+      return (index === 0 ? lowercaseFirstLetter : capitalizeFirstLetter)(item.trim());
+    }).join('');
+  }
+  return str;
+});

package/lib/generatePsdThumbnail/adaptHexBoundries.js

@@ -0,0 +1,9 @@
+var toLowerCaseWithTrim = function toLowerCaseWithTrim(string) {
+  return string.toLowerCase().replaceAll(/ /g, '');
+};
+var adaptHexBoundries = function adaptHexBoundries() {
+  var startingHex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var endingHex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  return [toLowerCaseWithTrim(startingHex), toLowerCaseWithTrim(endingHex)];
+};
+export default adaptHexBoundries;

package/lib/generatePsdThumbnail/bufferToHex.js

@@ -0,0 +1,12 @@
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var bufferToHex = function bufferToHex(buffer) {
+  return _toConsumableArray(new Uint8Array(buffer)).map(function (x) {
+    return x.toString(16).padStart(2, '0');
+  }).join('');
+};
+export default bufferToHex;

package/lib/generatePsdThumbnail/generatePsdThumbnail.js

@@ -0,0 +1,36 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _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(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+import { IMAGE_START_HEX, IMAGE_END_HEX, FIFTY_KILO_BYTES } from '@scaleflex/widget-utils/lib/constants';
+import bufferToHex from '@scaleflex/widget-utils/lib/generatePsdThumbnail/bufferToHex';
+import generatePsdThumbnailHex from '@scaleflex/widget-utils/lib/generatePsdThumbnail/generatePsdThumbnailHex';
+import generatePsdThumbnailBytes from '@scaleflex/widget-utils/lib/generatePsdThumbnail/generatePsdThumbnailBytes';
+import adaptHexBoundries from '@scaleflex/widget-utils/lib/generatePsdThumbnail/adaptHexBoundries';
+var generatePsdThumbnail = function generatePsdThumbnail(fileData) {
+  return new Promise(function (resolve, reject) {
+    try {
+      var previewChunk = fileData.slice(0, FIFTY_KILO_BYTES);
+      var _adaptHexBoundries = adaptHexBoundries(IMAGE_START_HEX, IMAGE_END_HEX),
+        _adaptHexBoundries2 = _slicedToArray(_adaptHexBoundries, 2),
+        hexStart = _adaptHexBoundries2[0],
+        hexEnd = _adaptHexBoundries2[1];
+      var buffer = new FileReader();
+      buffer.readAsArrayBuffer(previewChunk);
+      buffer.onload = function () {
+        var bufferHex = bufferToHex(buffer.result);
+        var imageHex = generatePsdThumbnailHex(bufferHex, hexStart, hexEnd);
+        var imageBytes = generatePsdThumbnailBytes(imageHex);
+        var blob = new Blob([imageBytes], {
+          type: 'image/jpeg'
+        });
+        resolve(URL.createObjectURL(blob));
+      };
+    } catch (err) {
+      reject(err);
+    }
+  });
+};
+export default generatePsdThumbnail;

package/lib/generatePsdThumbnail/generatePsdThumbnailBytes.js

@@ -0,0 +1,8 @@
+var generatePsdThumbnailBytes = function generatePsdThumbnailBytes(imageHex) {
+  var bytes = new Uint8Array(imageHex.length / 2);
+  for (var i = 0; i < imageHex.length; i += 2) {
+    bytes[i / 2] = parseInt(imageHex.substring(i, i + 2), 16);
+  }
+  return bytes;
+};
+export default generatePsdThumbnailBytes;

package/lib/generatePsdThumbnail/generatePsdThumbnailHex.js

@@ -0,0 +1,4 @@
+var generatePsdThumbnailHex = function generatePsdThumbnailHex(bufferHex, imageHexStart, imageHexEnd) {
+  return bufferHex.substring(bufferHex.indexOf(imageHexStart), bufferHex.indexOf(imageHexEnd) + imageHexEnd.length);
+};
+export default generatePsdThumbnailHex;

package/lib/generateSelectInputPlaceholder.js

@@ -0,0 +1,24 @@
+var style = {
+  opacity: 1,
+  border: 0,
+  background: 'transparent',
+  padding: '5px 12px',
+  fontSize: 14
+};
+
+/**
+ * [TODO] We may remove this util when this feature implemented in Scaleflex UI
+ * @param {string} placeholder
+ * @param {value} string
+ * @param {value} Array
+ * @returns {Object} placeholder with styles
+ */
+
+export default function generateSelectInputPlaceholder(placeholder) {
+  var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  if (value.length) return;
+  return {
+    placeholder: placeholder,
+    style: style
+  };
+}

package/lib/getActionErrorState.js

@@ -0,0 +1,17 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var getActionErrorState = function getActionErrorState(state, action) {
+  var _action$meta;
+  var noOtherStates = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var showAbortError = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var error = (_action$meta = action.meta) !== null && _action$meta !== void 0 && _action$meta.aborted && !showAbortError ? null : action.error;
+  return noOtherStates ? error : error && _objectSpread(_objectSpread({}, state), {}, {
+    error: error,
+    loading: false
+  }) || state;
+};
+export default getActionErrorState;

package/lib/getArraysMutualObjects.js

@@ -0,0 +1,12 @@
+var getArraysMutualObjects = function getArraysMutualObjects() {
+  var arraysOfObjects = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var propertyUsedInCompare = arguments.length > 1 ? arguments[1] : undefined;
+  return Array.isArray(arraysOfObjects) && propertyUsedInCompare && (arraysOfObjects.length > 1 ? arraysOfObjects.reduce(function (mutualObjectsArray, currArray) {
+    return currArray.filter(function (currObj) {
+      return mutualObjectsArray.some(function (mutualCurrObj) {
+        return mutualCurrObj[propertyUsedInCompare] === currObj[propertyUsedInCompare];
+      });
+    });
+  }) : arraysOfObjects[0]);
+};
+export default getArraysMutualObjects;

package/lib/getBytesRemaining.js

@@ -0,0 +1,9 @@
+var getBytesRemaining = function getBytesRemaining(files) {
+  return files.reduce(function (total, file) {
+    if (!file.progress.bytesFinished) {
+      return total + (100 - file.progress.percentage);
+    }
+    return total + (file.progress.bytesTotal - file.progress.bytesFinished);
+  }, 0);
+};
+export default getBytesRemaining;

package/lib/getClientTimezone.js

@@ -0,0 +1,5 @@
+var getClientTimezone = function getClientTimezone() {
+  var _Intl, _Intl$DateTimeFormat, _Intl$DateTimeFormat$, _Intl$DateTimeFormat$2;
+  return ((_Intl = Intl) === null || _Intl === void 0 ? void 0 : (_Intl$DateTimeFormat = _Intl.DateTimeFormat) === null || _Intl$DateTimeFormat === void 0 ? void 0 : (_Intl$DateTimeFormat$ = (_Intl$DateTimeFormat$2 = _Intl$DateTimeFormat.call(_Intl)).resolvedOptions) === null || _Intl$DateTimeFormat$ === void 0 ? void 0 : _Intl$DateTimeFormat$.call(_Intl$DateTimeFormat$2).timeZone) || '';
+};
+export default getClientTimezone;

package/lib/getCloudimagePrefixedUrl.js

@@ -0,0 +1,23 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+/**
+ * Get url prefixed by Cloudimage, to be able to process original image and cache it on CDN.
+ * @param {string} url - Original URL
+ * @param {object} opts
+ * @param {object} opts.params - Cloudimage params (https://docs.scaleflex.com/filerobot-documentation/media-optimizers-and-cdn-delivery/image-optimization)
+ * @returns {string} - Prefixed url with params
+ */
+var getCloudimagePrefixedUrl = function getCloudimagePrefixedUrl(url, opts) {
+  var _url$split;
+  var _ref = opts || {},
+    _ref$params = _ref.params,
+    params = _ref$params === void 0 ? {} : _ref$params;
+  if (typeof url !== 'string') {
+    return url;
+  }
+  var formattedUrl = (_url$split = url.split('?')) === null || _url$split === void 0 ? void 0 : _url$split[0];
+  var paramsStr = params && _typeof(params) === 'object' ? Object.keys(params).map(function (paramName) {
+    return "".concat(paramName, "=").concat(params[paramName]);
+  }).join('&') : '';
+  return "https://assets.filerobot.com/v7/".concat(formattedUrl).concat(paramsStr ? '?' : '').concat(paramsStr);
+};
+export default getCloudimagePrefixedUrl;

package/lib/getDateDaysFromNow.js

@@ -0,0 +1,17 @@
+import { ONE_DAY_MS } from './constants';
+var ONE_MIN_IN_MS = 1000 * 60;
+/**
+ * Returns a date days from now
+ * @param {Number} days - sets the new date by adding the provided number of days for the current date
+ * @param {Boolean} timeExcluded - either to return timestamp with time (hours, minutes etc) or without
+ * @returns {number} - timestamp in milliseconds
+ */
+
+export default (function (_ref) {
+  var days = _ref.days,
+    _ref$timeExcluded = _ref.timeExcluded,
+    timeExcluded = _ref$timeExcluded === void 0 ? true : _ref$timeExcluded;
+  var todayTimestamp = timeExcluded ? Date.now() - Date.now() % ONE_DAY_MS + new Date().getTimezoneOffset() * ONE_MIN_IN_MS : Date.now();
+  var now = new Date(todayTimestamp);
+  return now.setDate(now.getDate() + days);
+});

package/lib/getDateMinusDay.js

@@ -0,0 +1,5 @@
+import { ONE_DAY_MS } from './constants';
+var getDateMinusDay = function getDateMinusDay(dateStr) {
+  return new Date(Date.parse(!dateStr || isNaN(new Date(dateStr)) ? new Date() : dateStr) - ONE_DAY_MS);
+};
+export default getDateMinusDay;

package/lib/getDateString.js

@@ -0,0 +1,20 @@
+/**
+ * Returns a date in the all formats
+ */
+
+export default function getDateString(format, spaceType, timeStamp) {
+  var dateObject = timeStamp ? new Date(timeStamp) : new Date();
+  var getMonth = dateObject.getMonth() + 1;
+  var getDay = dateObject.getDate();
+  var month = getMonth < 10 ? '0' + getMonth : getMonth;
+  var day = getDay < 10 ? '0' + getDay : getDay;
+  var year = dateObject.getFullYear();
+  switch (format) {
+    case 'mdy':
+      return month + spaceType + day + spaceType + year;
+    case 'dmy':
+      return day + spaceType + month + spaceType + year;
+    case 'ymd':
+      return year + spaceType + month + spaceType + day;
+  }
+}

package/lib/getDaysLeft.js

@@ -0,0 +1,9 @@
+var oneDay = 24 * 60 * 60 * 1000; // hours*minutes*seconds*milliseconds
+
+var getDaysLeft = function getDaysLeft(date) {
+  var dateNow = Date.now();
+  var finalDay = new Date(date);
+  if (isNaN(finalDay)) return;
+  return -((dateNow - finalDay) / oneDay);
+};
+export default getDaysLeft;

package/lib/getDecodedUriComponent.js

@@ -0,0 +1,10 @@
+var getDecodedUriComponent = function getDecodedUriComponent(value) {
+  var decodedValue = value;
+  if (typeof decodedValue === 'string') {
+    try {
+      decodedValue = decodeURIComponent(decodedValue);
+    } catch (e) {}
+  }
+  return decodedValue;
+};
+export default getDecodedUriComponent;

package/lib/getDownloadSpeed.js

@@ -0,0 +1,7 @@
+export default function getDownloadSpeed(_ref) {
+  var downloadStartedAt = _ref.downloadStartedAt,
+    downloaded = _ref.downloaded;
+  var timeElapsed = new Date() - downloadStartedAt;
+  var downloadSpeed = downloaded / (timeElapsed / 1000);
+  return downloadSpeed || 1;
+}

package/lib/getDroppedFiles/index.js

@@ -0,0 +1,24 @@
+import webkitGetAsEntryApi from './utils/webkitGetAsEntryApi/index';
+import fallbackApi from './utils/fallbackApi';
+
+/**
+ * Returns a promise that resolves to the array of dropped files (if a folder is dropped, and browser supports folder parsing - promise resolves to the flat array of all files in all directories).
+ * Each file has .relativePath prop appended to it (e.g. "/docs/Prague/ticket_from_prague_to_ufa.pdf") if browser supports it. Otherwise it's undefined.
+ *
+ * @param {DataTransfer} dataTransfer
+ * @param {Function} logDropError - a function that's called every time some folder or some file error out (e.g. because of the folder name being too long on Windows). Notice that resulting promise will always be resolved anyway.
+ *
+ * @returns {Promise} - Array<File>
+ */
+export default function getDroppedFiles(dataTransfer) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$logDropError = _ref.logDropError,
+    logDropError = _ref$logDropError === void 0 ? function () {} : _ref$logDropError;
+  // Get all files from all subdirs. Works (at least) in Chrome, Mozilla, and Safari
+  if (dataTransfer.items && dataTransfer.items[0] && 'webkitGetAsEntry' in dataTransfer.items[0]) {
+    return webkitGetAsEntryApi(dataTransfer, logDropError);
+    // Otherwise just return all first-order files
+  } else {
+    return fallbackApi(dataTransfer);
+  }
+}

package/lib/getDroppedFiles/utils/fallbackApi.js

@@ -0,0 +1,7 @@
+import toArray from '../../toArray';
+
+// .files fallback, should be implemented in any browser
+export default function fallbackApi(dataTransfer) {
+  var files = toArray(dataTransfer.files);
+  return Promise.resolve(files);
+}

package/lib/getDroppedFiles/utils/webkitGetAsEntryApi/getFilesAndDirectoriesFromDirectory.js

@@ -0,0 +1,36 @@
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Recursive function, calls the original callback() when the directory is entirely parsed.
+ *
+ * @param {FileSystemDirectoryReader} directoryReader
+ * @param {Array} oldEntries
+ * @param {Function} logDropError
+ * @param {Function} callback - called with ([ all files and directories in that directoryReader ])
+ */
+export default function getFilesAndDirectoriesFromDirectory(directoryReader, oldEntries, logDropError, _ref) {
+  var onSuccess = _ref.onSuccess;
+  directoryReader.readEntries(function (entries) {
+    var newEntries = [].concat(_toConsumableArray(oldEntries), _toConsumableArray(entries));
+    // According to the FileSystem API spec, getFilesAndDirectoriesFromDirectory() must be called until it calls the onSuccess with an empty array.
+    if (entries.length) {
+      setTimeout(function () {
+        getFilesAndDirectoriesFromDirectory(directoryReader, newEntries, logDropError, {
+          onSuccess: onSuccess
+        });
+      }, 0);
+      // Done iterating this particular directory
+    } else {
+      onSuccess(newEntries);
+    }
+  },
+  // Make sure we resolve on error anyway, it's fine if only one directory couldn't be parsed!
+  function (error) {
+    logDropError(error);
+    onSuccess(oldEntries);
+  });
+}

package/lib/getDroppedFiles/utils/webkitGetAsEntryApi/getRelativePath.js

@@ -0,0 +1,16 @@
+/**
+ * Get the relative path from the FileEntry#fullPath, because File#webkitRelativePath is always '', at least onDrop.
+ *
+ * @param {FileEntry} fileEntry
+ *
+ * @returns {string|null} - if file is not in a folder - return null (this is to be consistent with .relativePath-s of files selected from My Device). If file is in a folder - return its fullPath, e.g. '/simpsons/hi.jpeg'.
+ */
+export default function getRelativePath(fileEntry) {
+  // fileEntry.fullPath - "/simpsons/hi.jpeg" or undefined (for browsers that don't support it)
+  // fileEntry.name - "hi.jpeg"
+  if (!fileEntry.fullPath || fileEntry.fullPath === '/' + fileEntry.name) {
+    return null;
+  } else {
+    return fileEntry.fullPath;
+  }
+}