@bringg/dashboard-sdk 9.55.0 → 9.56.0

package/dist/bringg-dashboard-sdk-cjs2.js

@@ -22426,7 +22426,7 @@ var lodash_1 = __webpack_require__(96486);
 var BringgException_1 = __webpack_require__(43605);
 var Logger_1 = __importDefault(__webpack_require__(55860));
 var abort_1 = __webpack_require__(34179);
-var version = '9.55.0';
+var version = '9.56.0';
 function logErrorResponse(response) {
     var data = response.data, status = response.status;
     try {
@@ -29118,8 +29118,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MAX_CONCURRENT_CHUNKED_REQUESTS = exports.DEFAULT_CHUNK_SIZE = void 0;
 var types_1 = __webpack_require__(63127);
-var lodash_1 = __webpack_require__(96486);
+var chunk_1 = __importDefault(__webpack_require__(8400));
+var forEach_1 = __importDefault(__webpack_require__(84486));
+var last_1 = __importDefault(__webpack_require__(10928));
 var rxjs_1 = __webpack_require__(34143);
 var operators_1 = __webpack_require__(11717);
 var BaseStore_1 = __importDefault(__webpack_require__(14436));
@@ -29127,6 +29130,9 @@ var UsersService_1 = __importDefault(__webpack_require__(95401));
 var User_consts_1 = __webpack_require__(38894);
 var UserHelpers_1 = __webpack_require__(2450);
 var THROTTLE_TIME = 500;
+var MIN_INTERVAL_BETWEEN_CHUNKED_REQUESTS = 300;
+exports.DEFAULT_CHUNK_SIZE = 50;
+exports.MAX_CONCURRENT_CHUNKED_REQUESTS = 4;
 var UsersStore = /** @class */ (function (_super) {
     __extends(UsersStore, _super);
     function UsersStore(session, throttleTimeValue) {
@@ -29323,7 +29329,7 @@ var UsersStore = /** @class */ (function (_super) {
                     case 0: return [4 /*yield*/, this.usersService.getAll(page, limit)];
                     case 1:
                         response = _a.sent();
-                        (0, lodash_1.forEach)(response.users, function (user) { return (_this.getItem(user.id) ? _this.updateInStore(user) : _this.addToStore(user)); });
+                        (0, forEach_1.default)(response.users, function (user) { return (_this.getItem(user.id) ? _this.updateInStore(user) : _this.addToStore(user)); });
                         return [2 /*return*/, response];
                 }
             });
@@ -29338,7 +29344,7 @@ var UsersStore = /** @class */ (function (_super) {
                     case 0: return [4 /*yield*/, this.usersService.getAllKeysetPagination(request)];
                     case 1:
                         response = _a.sent();
-                        (0, lodash_1.forEach)(response.users, function (user) { return (_this.getItem(user.id) ? _this.updateInStore(user) : _this.addToStore(user)); });
+                        (0, forEach_1.default)(response.users, function (user) { return (_this.getItem(user.id) ? _this.updateInStore(user) : _this.addToStore(user)); });
                         this.initGroups(this.getItems());
                         return [2 /*return*/, response];
                 }
@@ -29531,46 +29537,91 @@ var UsersStore = /** @class */ (function (_super) {
     };
     UsersStore.prototype.getMany = function (ids, commonOptions) {
         return __awaiter(this, void 0, void 0, function () {
-            var foundedItems, idsSet, missingIds, missingUsers;
+            var idsSet, uniqIds, foundItems, missingIds, missingUsers, missingIdsChunks, concurrentChunks, concurrentChunks_1, concurrentChunks_1_1, concurrentChunk, promises, rejectReason, results, results_1, results_1_1, result, users, e_8_1;
+            var e_8, _a, e_9, _b;
             var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        foundedItems = this.getItemsByIds(ids);
-                        if (foundedItems.length === ids.length) {
-                            return [2 /*return*/, foundedItems];
-                        }
                         idsSet = new Set(ids);
-                        foundedItems.forEach(function (user) { return idsSet.delete(user.id); });
+                        uniqIds = Array.from(idsSet);
+                        foundItems = this.getItemsByIds(uniqIds);
+                        if (foundItems.length === uniqIds.length) {
+                            return [2 /*return*/, foundItems];
+                        }
+                        foundItems.forEach(function (user) { return idsSet.delete(user.id); });
                         missingIds = Array.from(idsSet);
-                        return [4 /*yield*/, this.usersService.fetchAllPages(function (page) {
-                                if (page === void 0) { page = 1; }
-                                return __awaiter(_this, void 0, void 0, function () {
-                                    var response, fetchedUsers;
-                                    return __generator(this, function (_a) {
-                                        switch (_a.label) {
-                                            case 0: return [4 /*yield*/, this.usersService.getMany({
-                                                    usersIds: missingIds,
-                                                    page: page,
-                                                    limit: 50
-                                                }, commonOptions)];
-                                            case 1:
-                                                response = _a.sent();
-                                                fetchedUsers = response.users;
-                                                // Adding here and not after getting all, so we won't stop the event loop for too long, if we have a lot
-                                                this.addItems(fetchedUsers);
-                                                return [2 /*return*/, {
-                                                        values: fetchedUsers,
-                                                        hasMore: response.has_next_page,
-                                                        nextCursor: page + 1
-                                                    }];
-                                        }
-                                    });
-                                });
-                            }, { signal: commonOptions === null || commonOptions === void 0 ? void 0 : commonOptions.signal })];
+                        missingUsers = [];
+                        missingIdsChunks = (0, chunk_1.default)(missingIds, exports.DEFAULT_CHUNK_SIZE);
+                        concurrentChunks = (0, chunk_1.default)(missingIdsChunks, exports.MAX_CONCURRENT_CHUNKED_REQUESTS);
+                        _c.label = 1;
                     case 1:
-                        missingUsers = _a.sent();
-                        return [2 /*return*/, foundedItems.concat(missingUsers)];
+                        _c.trys.push([1, 6, 7, 8]);
+                        concurrentChunks_1 = __values(concurrentChunks), concurrentChunks_1_1 = concurrentChunks_1.next();
+                        _c.label = 2;
+                    case 2:
+                        if (!!concurrentChunks_1_1.done) return [3 /*break*/, 5];
+                        concurrentChunk = concurrentChunks_1_1.value;
+                        promises = concurrentChunk.map(function (idsChunk) { return __awaiter(_this, void 0, void 0, function () {
+                            var chunkResult;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.usersService.getMany({ usersIds: idsChunk }, commonOptions)];
+                                    case 1:
+                                        chunkResult = _a.sent();
+                                        return [2 /*return*/, chunkResult.users];
+                                }
+                            });
+                        }); });
+                        // Rate limit to one set of requests per MIN_INTERVAL_BETWEEN_CHUNKED_REQUESTS
+                        if (concurrentChunk !== (0, last_1.default)(concurrentChunks)) {
+                            promises.push(new Promise(function (resolve) { return setTimeout(function () { return resolve([]); }, MIN_INTERVAL_BETWEEN_CHUNKED_REQUESTS); }));
+                        }
+                        rejectReason = null;
+                        return [4 /*yield*/, Promise.allSettled(promises)];
+                    case 3:
+                        results = _c.sent();
+                        try {
+                            for (results_1 = (e_9 = void 0, __values(results)), results_1_1 = results_1.next(); !results_1_1.done; results_1_1 = results_1.next()) {
+                                result = results_1_1.value;
+                                if (result.status === 'fulfilled') {
+                                    users = result.value;
+                                    missingUsers.push.apply(missingUsers, __spreadArray([], __read(users), false));
+                                    this.addItems(users);
+                                }
+                                else {
+                                    if (!rejectReason) {
+                                        rejectReason = result.reason;
+                                    }
+                                }
+                            }
+                        }
+                        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                        finally {
+                            try {
+                                if (results_1_1 && !results_1_1.done && (_b = results_1.return)) _b.call(results_1);
+                            }
+                            finally { if (e_9) throw e_9.error; }
+                        }
+                        if (rejectReason) {
+                            throw rejectReason;
+                        }
+                        _c.label = 4;
+                    case 4:
+                        concurrentChunks_1_1 = concurrentChunks_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_8_1 = _c.sent();
+                        e_8 = { error: e_8_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (concurrentChunks_1_1 && !concurrentChunks_1_1.done && (_a = concurrentChunks_1.return)) _a.call(concurrentChunks_1);
+                        }
+                        finally { if (e_8) throw e_8.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/, foundItems.concat(missingUsers)];
                 }
             });
         });
@@ -46918,6 +46969,44 @@ var baseSetToString = !defineProperty ? identity : function(func, string) {
 module.exports = baseSetToString;
 
 
+/***/ }),
+
+/***/ 14259:
+/***/ ((module) => {
+
+/**
+ * The base implementation of `_.slice` without an iteratee call guard.
+ *
+ * @private
+ * @param {Array} array The array to slice.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the slice of `array`.
+ */
+function baseSlice(array, start, end) {
+  var index = -1,
+      length = array.length;
+
+  if (start < 0) {
+    start = -start > length ? 0 : (length + start);
+  }
+  end = end > length ? length : end;
+  if (end < 0) {
+    end += length;
+  }
+  length = start > end ? 0 : ((end - start) >>> 0);
+  start >>>= 0;
+
+  var result = Array(length);
+  while (++index < length) {
+    result[index] = array[index + start];
+  }
+  return result;
+}
+
+module.exports = baseSlice;
+
+
 /***/ }),
 
 /***/ 22545:
@@ -46989,6 +47078,32 @@ function baseToString(value) {
 module.exports = baseToString;
 
 
+/***/ }),
+
+/***/ 27561:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var trimmedEndIndex = __webpack_require__(67990);
+
+/** Used to match leading whitespace. */
+var reTrimStart = /^\s+/;
+
+/**
+ * The base implementation of `_.trim`.
+ *
+ * @private
+ * @param {string} string The string to trim.
+ * @returns {string} Returns the trimmed string.
+ */
+function baseTrim(string) {
+  return string
+    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
+    : string;
+}
+
+module.exports = baseTrim;
+
+
 /***/ }),
 
 /***/ 7518:
@@ -47056,6 +47171,27 @@ function cacheHas(cache, key) {
 module.exports = cacheHas;
 
 
+/***/ }),
+
+/***/ 54290:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var identity = __webpack_require__(6557);
+
+/**
+ * Casts `value` to `identity` if it's not a function.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {Function} Returns cast function.
+ */
+function castFunction(value) {
+  return typeof value == 'function' ? value : identity;
+}
+
+module.exports = castFunction;
+
+
 /***/ }),
 
 /***/ 71811:
@@ -49834,6 +49970,32 @@ function toSource(func) {
 module.exports = toSource;
 
 
+/***/ }),
+
+/***/ 67990:
+/***/ ((module) => {
+
+/** Used to match a single whitespace character. */
+var reWhitespace = /\s/;
+
+/**
+ * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+ * character of `string`.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {number} Returns the index of the last non-whitespace character.
+ */
+function trimmedEndIndex(string) {
+  var index = string.length;
+
+  while (index-- && reWhitespace.test(string.charAt(index))) {}
+  return index;
+}
+
+module.exports = trimmedEndIndex;
+
+
 /***/ }),
 
 /***/ 29018:
@@ -49921,6 +50083,63 @@ var attempt = baseRest(function(func, args) {
 module.exports = attempt;
 
 
+/***/ }),
+
+/***/ 8400:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseSlice = __webpack_require__(14259),
+    isIterateeCall = __webpack_require__(16612),
+    toInteger = __webpack_require__(40554);
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeCeil = Math.ceil,
+    nativeMax = Math.max;
+
+/**
+ * Creates an array of elements split into groups the length of `size`.
+ * If `array` can't be split evenly, the final chunk will be the remaining
+ * elements.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Array
+ * @param {Array} array The array to process.
+ * @param {number} [size=1] The length of each chunk
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Array} Returns the new array of chunks.
+ * @example
+ *
+ * _.chunk(['a', 'b', 'c', 'd'], 2);
+ * // => [['a', 'b'], ['c', 'd']]
+ *
+ * _.chunk(['a', 'b', 'c', 'd'], 3);
+ * // => [['a', 'b', 'c'], ['d']]
+ */
+function chunk(array, size, guard) {
+  if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {
+    size = 1;
+  } else {
+    size = nativeMax(toInteger(size), 0);
+  }
+  var length = array == null ? 0 : array.length;
+  if (!length || size < 1) {
+    return [];
+  }
+  var index = 0,
+      resIndex = 0,
+      result = Array(nativeCeil(length / size));
+
+  while (index < length) {
+    result[resIndex++] = baseSlice(array, index, (index += size));
+  }
+  return result;
+}
+
+module.exports = chunk;
+
+
 /***/ }),
 
 /***/ 50361:
@@ -50113,6 +50332,54 @@ function flatten(array) {
 module.exports = flatten;
 
 
+/***/ }),
+
+/***/ 84486:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var arrayEach = __webpack_require__(77412),
+    baseEach = __webpack_require__(89881),
+    castFunction = __webpack_require__(54290),
+    isArray = __webpack_require__(1469);
+
+/**
+ * Iterates over elements of `collection` and invokes `iteratee` for each element.
+ * The iteratee is invoked with three arguments: (value, index|key, collection).
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * **Note:** As with other "Collections" methods, objects with a "length"
+ * property are iterated like arrays. To avoid this behavior use `_.forIn`
+ * or `_.forOwn` for object iteration.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @alias each
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ * @see _.forEachRight
+ * @example
+ *
+ * _.forEach([1, 2], function(value) {
+ *   console.log(value);
+ * });
+ * // => Logs `1` then `2`.
+ *
+ * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
+ *   console.log(key);
+ * });
+ * // => Logs 'a' then 'b' (iteration order is not guaranteed).
+ */
+function forEach(collection, iteratee) {
+  var func = isArray(collection) ? arrayEach : baseEach;
+  return func(collection, castFunction(iteratee));
+}
+
+module.exports = forEach;
+
+
 /***/ }),
 
 /***/ 27361:
@@ -51002,6 +51269,33 @@ function keysIn(object) {
 module.exports = keysIn;
 
 
+/***/ }),
+
+/***/ 10928:
+/***/ ((module) => {
+
+/**
+ * Gets the last element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {*} Returns the last element of `array`.
+ * @example
+ *
+ * _.last([1, 2, 3]);
+ * // => 3
+ */
+function last(array) {
+  var length = array == null ? 0 : array.length;
+  return length ? array[length - 1] : undefined;
+}
+
+module.exports = last;
+
+
 /***/ }),
 
 /***/ 96486:
@@ -68770,6 +69064,169 @@ var templateSettings = {
 module.exports = templateSettings;
 
 
+/***/ }),
+
+/***/ 18601:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var toNumber = __webpack_require__(14841);
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0,
+    MAX_INTEGER = 1.7976931348623157e+308;
+
+/**
+ * Converts `value` to a finite number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.12.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted number.
+ * @example
+ *
+ * _.toFinite(3.2);
+ * // => 3.2
+ *
+ * _.toFinite(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toFinite(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toFinite('3.2');
+ * // => 3.2
+ */
+function toFinite(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber(value);
+  if (value === INFINITY || value === -INFINITY) {
+    var sign = (value < 0 ? -1 : 1);
+    return sign * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
+
+module.exports = toFinite;
+
+
+/***/ }),
+
+/***/ 40554:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var toFinite = __webpack_require__(18601);
+
+/**
+ * Converts `value` to an integer.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.toInteger(3.2);
+ * // => 3
+ *
+ * _.toInteger(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toInteger(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toInteger('3.2');
+ * // => 3
+ */
+function toInteger(value) {
+  var result = toFinite(value),
+      remainder = result % 1;
+
+  return result === result ? (remainder ? result - remainder : result) : 0;
+}
+
+module.exports = toInteger;
+
+
+/***/ }),
+
+/***/ 14841:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseTrim = __webpack_require__(27561),
+    isObject = __webpack_require__(13218),
+    isSymbol = __webpack_require__(33448);
+
+/** Used as references for various `Number` constants. */
+var NAN = 0 / 0;
+
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+
+/** Built-in method references without a dependency on `root`. */
+var freeParseInt = parseInt;
+
+/**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */
+function toNumber(value) {
+  if (typeof value == 'number') {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject(value)) {
+    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+    value = isObject(other) ? (other + '') : other;
+  }
+  if (typeof value != 'string') {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return (isBinary || reIsOctal.test(value))
+    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+    : (reIsBadHex.test(value) ? NAN : +value);
+}
+
+module.exports = toNumber;
+
+
 /***/ }),
 
 /***/ 79833: