@aurigma/design-atoms
Version:
Design Atoms is a part of Customer's Canvas SDK which allows for manipulating individual design elements through your code.
157 lines • 6.85 kB
JavaScript
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var MultiCallRequest = /** @class */ (function () {
function MultiCallRequest(_service, _imageLoaderService) {
this._service = _service;
this._imageLoaderService = _imageLoaderService;
this._multiCallInProgress = false;
this._multiCallItems = null;
this._multiCallCallbacks = null;
this._endMultiCallPromiseFuncs = null;
this._multiCallInProgress = false;
this._multiCallItems = [];
this._multiCallCallbacks = [];
this._multiCallCounter = 0;
this._endMultiCallPromiseFuncs = [];
}
MultiCallRequest.prototype.increaseCounter = function () {
this._multiCallCounter++;
};
MultiCallRequest.prototype.decreaseCounter = function () {
this._multiCallCounter--;
return this._multiCallCounter;
};
MultiCallRequest.prototype.enqueueEndMultiCall = function () {
var _this = this;
return new Promise(function (resolve, reject) { return _this._endMultiCallPromiseFuncs.push([resolve, reject]); });
};
Object.defineProperty(MultiCallRequest.prototype, "multiCallStarted", {
get: function () {
return this._multiCallCounter > 0;
},
enumerable: true,
configurable: true
});
MultiCallRequest.prototype.beginMultiCall = function () {
this.increaseCounter();
};
MultiCallRequest.prototype.endMultiCall = function (requestImage) {
if (requestImage === void 0) { requestImage = true; }
if (this.decreaseCounter() > 0) {
return this.enqueueEndMultiCall();
}
if (this._multiCallItems == null || this._multiCallItems.length < 1) {
this._onMultiCallFinally();
return Promise.resolve(false);
}
var items = this._multiCallItems;
var callbacks = this._multiCallCallbacks;
var promiseFuncs = this._endMultiCallPromiseFuncs;
this._multiCallItems = [];
this._multiCallCallbacks = [];
this._endMultiCallPromiseFuncs = [];
return this._updateByMultiCall(items, callbacks, promiseFuncs, requestImage);
};
MultiCallRequest.prototype.queueForMultiCall = function (data, success, failure) {
if (this._multiCallInProgress)
return false;
this._multiCallItems.push(data);
this._multiCallCallbacks.push([success, failure]);
return true;
};
MultiCallRequest.prototype._updateByMultiCall = function (items, callbacks, promiseFuncs, requestImage) {
//const base64 = this._compressAsBase64({ items });
var _this = this;
if (requestImage === void 0) { requestImage = true; }
this._multiCallInProgress = true;
return new Promise(function (resolve, reject) {
var filteredItems = _this._filter(items, callbacks);
_this._updateByMultiCallRequest({ items: filteredItems.items }, function (response) { return _this._onMultiCallDone(response, filteredItems.callbacks, resolve, promiseFuncs, requestImage); }, function (error, userContext, methodName) { return _this._onMultiCallFailed(error, userContext, methodName, items, callbacks, reject, promiseFuncs); });
});
};
MultiCallRequest.prototype._filter = function (items, callbacks) {
items = items.reverse();
callbacks = callbacks.reverse();
var uniqIdsIndexes = [];
var itemDataIds = [];
items = items.filter(function (d, index) {
if (d.itemData == null || itemDataIds.includes(d.itemData.id))
return false;
itemDataIds.push(d.itemData.id);
uniqIdsIndexes.push(index);
return true;
});
return {
items: items,
callbacks: uniqIdsIndexes.map(function (i) { return callbacks[i]; })
};
};
MultiCallRequest.prototype._onMultiCallDone = function (data, callbacks, updateByMultiCallResolve, promiseFuncs, requestImage) {
//const data = this._unZip(base64Response);
if (requestImage === void 0) { requestImage = true; }
try {
if (requestImage)
this._imageLoaderService.loadCombinedImage(data.combinedImageDescription);
var resultItems = data.items;
for (var i = 0; i < resultItems.length; i++)
this._processItemResult(resultItems[i], callbacks[i]);
}
finally {
this._onMultiCallFinally();
updateByMultiCallResolve(true);
if (promiseFuncs != null)
promiseFuncs.forEach(function (x) { return x[0](true); });
}
};
MultiCallRequest.prototype._processItemResult = function (resultItem, callbacks) {
try {
var _a = __read(callbacks, 2), successCallback = _a[0], failedCallback = _a[1];
if (resultItem.error)
failedCallback({ errorMessage: resultItem.errorMessage });
else {
successCallback(resultItem.result);
}
}
catch (e) {
console.error("Error while processing ItemHandlers service response", e);
}
};
MultiCallRequest.prototype._onMultiCallFailed = function (error, userContext, methodName, items, callbacks, updateByMultiCallReject, promiseFuncs) {
try {
for (var i = 0; i < callbacks.length; i++)
if (callbacks[i][1])
callbacks[i][1](error, userContext, methodName);
}
finally {
this._onMultiCallFinally();
updateByMultiCallReject();
if (promiseFuncs != null)
promiseFuncs.forEach(function (x) { return x[1](); });
}
};
MultiCallRequest.prototype._updateByMultiCallRequest = function (data, resolve, failure) {
this._service.sendRequest("UpdateByMultiCallRequest", data, resolve, failure);
};
MultiCallRequest.prototype._onMultiCallFinally = function () {
this._multiCallInProgress = false;
this._multiCallItems = [];
this._multiCallCallbacks = [];
};
return MultiCallRequest;
}());
export { MultiCallRequest };
//# sourceMappingURL=MultiCallRequest.js.map