intelicoreact 1.5.32 → 1.5.34

package/dist/src/Classes/AbortableFetch.js

@@ -0,0 +1,400 @@
+/* eslint-disable no-unused-vars */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+const RESPONSE_AS_OBJECT_ALWAYS_VALUE = "always";
+var _pathPrefix = /*#__PURE__*/ new WeakMap(), _method = /*#__PURE__*/ new WeakMap(), _queryParameters = /*#__PURE__*/ new WeakMap(), _headers = /*#__PURE__*/ new WeakMap(), _body = /*#__PURE__*/ new WeakMap(), _options = /*#__PURE__*/ new WeakMap(), _callback = /*#__PURE__*/ new WeakMap(), _catchCallback = /*#__PURE__*/ new WeakMap(), _everyPromiseCallback = /*#__PURE__*/ new WeakMap(), _isResponseAsObject = /*#__PURE__*/ new WeakMap();
+class AbortableFetch {
+    request(props) {
+        if (!props || typeof props !== "object" && typeof props !== "string") throw new Error("Not valid props value!");
+        const stringifyBody = (b)=>(b === null || b === void 0 ? void 0 : b.constructor) === FormData ? b : JSON.stringify(b);
+        this.requestInput = props;
+        // eslint-disable-next-line no-use-before-define
+        const requests = getRequestsArray.call(this, props);
+        if (!requests.length) return Promise.reject(new Error("There are no any valid props"));
+        const abortController = new AbortController();
+        let externalRequest = Promise.all(requests.map(async (item)=>{
+            const safelyQuery = item.path.includes("?") ? `&${item.queryParameters.replace(/\?/g, "")}` : item.queryParameters;
+            let request = fetch(`${item.pathPrefix}${item.path}${safelyQuery}`, {
+                ...item.options,
+                method: item.method,
+                headers: item.headers,
+                ...item.body ? {
+                    body: stringifyBody(item.body)
+                } : {},
+                signal: abortController.signal
+            }).then((response)=>{
+                response.request = item;
+                return response;
+            }).catch((response)=>Promise.resolve({
+                    ok: false,
+                    status: 0,
+                    statusText: response,
+                    request: item
+                }));
+            if (_class_private_field_get(this, _everyPromiseCallback) && !item.isSkipEveryPromiseCallback) request = request.then((response)=>_class_private_field_get(this, _everyPromiseCallback).call(this, response));
+            if (item.callback) request = request.then((response)=>item.callback(response));
+            if (_class_private_field_get(this, _isResponseAsObject)) request = request.then((response)=>({
+                    name: item.name,
+                    response
+                }));
+            return request;
+        }));
+        externalRequest = externalRequest.then((response)=>response.length < 2 ? response[0] : response);
+        if (_class_private_field_get(this, _isResponseAsObject)) {
+            externalRequest = externalRequest.then((response)=>{
+                if (Array.isArray(props) && props.length > 1) return response.reduce((ac, item)=>({
+                        ...ac,
+                        [item.name]: item.response
+                    }), {});
+                else return _class_private_field_get(this, _isResponseAsObject) === RESPONSE_AS_OBJECT_ALWAYS_VALUE ? {
+                    [response.name]: response.response
+                } : response.response;
+            });
+        }
+        externalRequest = externalRequest.then((response)=>_class_private_field_get(this, _callback) ? _class_private_field_get(this, _callback).call(this, response) : response);
+        externalRequest = externalRequest.catch((error)=>_class_private_field_get(this, _catchCallback) ? _class_private_field_get(this, _catchCallback).call(this, error) : error);
+        // eslint-disable-next-line no-proto
+        externalRequest.__proto__.abort = ()=>abortController.abort();
+        return externalRequest;
+        function getRequestsArray(input) {
+            const requestsArray = (()=>{
+                if (typeof input === "string") return [
+                    {
+                        path: input
+                    }
+                ];
+                return Array.isArray(input) ? [
+                    ...input
+                ] : [
+                    input
+                ];
+            })();
+            return requestsArray.reduce((ac, item, index)=>{
+                const itemObj = typeof item === "object" && item !== null && !Array.isArray(item) ? item : {};
+                const { name, path, method, queryParameters, headers, body, options, callback, mergeProps, isNoPathPrefix, isSkipEveryPromiseCallback } = itemObj;
+                const safelyMergeProps = mergeProps instanceof Object && !Array.isArray(mergeProps) ? mergeProps : {};
+                const getMergeProps = (key)=>{
+                    var _safelyMergeProps_all;
+                    return (_safelyMergeProps_all = safelyMergeProps.all) !== null && _safelyMergeProps_all !== void 0 ? _safelyMergeProps_all : safelyMergeProps[key];
+                };
+                if (!path || typeof path !== "string") return ac;
+                const { name: omitName, path: omitPath, pathPrefix: omitPathPrefix, method: omitMethod, queryParameters: omitQueryParameters, headers: omitHeaders, body: omitBody, options: omitOptions, callback: omitCallback, mergeProps: omitMergeProps, ...optionsRest } = options || {};
+                return [
+                    ...ac,
+                    {
+                        path,
+                        pathPrefix: getMergeProps("pathPrefix") === "onlyLocal" || isNoPathPrefix ? "" : _class_private_field_get(this, _pathPrefix) || "",
+                        method: (()=>{
+                            if (getMergeProps("method") === "onlyLocal") return method || "GET";
+                            return getMergeProps("method") === "onlyGlobal" ? _class_private_field_get(this, _method) || "GET" : method || _class_private_field_get(this, _method) || "GET";
+                        })(),
+                        queryParameters: (()=>{
+                            var _getMergeProps;
+                            if (((_getMergeProps = getMergeProps("queryParameters")) !== null && _getMergeProps !== void 0 ? _getMergeProps : getMergeProps("query")) === "onlyLocal") {
+                                return this.getQueryString(this.getQueryArray(queryParameters));
+                            }
+                            var _getMergeProps1;
+                            return ((_getMergeProps1 = getMergeProps("queryParameters")) !== null && _getMergeProps1 !== void 0 ? _getMergeProps1 : getMergeProps("query")) === "onlyGlobal" ? this.getQueryString(this.getQueryArray(_class_private_field_get(this, _queryParameters))) : this.getQueryString([
+                                ...this.getQueryArray(_class_private_field_get(this, _queryParameters)),
+                                ...this.getQueryArray(queryParameters)
+                            ]);
+                        })(),
+                        headers: (()=>{
+                            if (getMergeProps("headers") === "onlyLocal") return this.getHeadersObj(headers || {});
+                            return getMergeProps("headers") === "onlyGlobal" ? this.getHeadersObj({
+                                ..._class_private_field_get(this, _headers) || {}
+                            }) : this.getHeadersObj({
+                                ..._class_private_field_get(this, _headers) || {},
+                                ...headers || {}
+                            });
+                        })(),
+                        body: (()=>{
+                            if (getMergeProps("body") === "onlyLocal") return body || null;
+                            if (getMergeProps("body") === "onlyGlobal") return _class_private_field_get(this, _body) || null;
+                            if (body && _class_private_field_get(this, _body) && typeof body === typeof _class_private_field_get(this, _body) && typeof body === "object") {
+                                return Array.isArray(body) ? [
+                                    ..._class_private_field_get(this, _body),
+                                    ...body
+                                ] : {
+                                    ..._class_private_field_get(this, _body),
+                                    ...body
+                                };
+                            } else return body || _class_private_field_get(this, _body) || null;
+                        })(),
+                        options: (()=>{
+                            if (getMergeProps("options") === "onlyLocal") return {
+                                ...optionsRest || {}
+                            };
+                            return getMergeProps("options") === "onlyGlobal" ? {
+                                ..._class_private_field_get(this, _options) || {}
+                            } : {
+                                ..._class_private_field_get(this, _options) || {},
+                                ...optionsRest || {}
+                            };
+                        })(),
+                        callback,
+                        isSkipEveryPromiseCallback,
+                        ...this.getIsResponseAsObject() ? {
+                            name: name && typeof name === "string" ? name : index
+                        } : {}
+                    }
+                ];
+            }, []);
+        }
+    }
+    repeatRequest() {
+        return this.request(this.requestInput);
+    }
+    // ***** getters and setters *****
+    getPathPrefix() {
+        return _class_private_field_get(this, _pathPrefix);
+    }
+    setPathPrefix(value) {
+        if (value && typeof value !== "string") throw new Error("Not valid pathPrefix value!");
+        _class_private_field_set(this, _pathPrefix, value || null);
+    }
+    getMethod() {
+        return _class_private_field_get(this, _method);
+    }
+    setMethod(value) {
+        const methods = [
+            "GET",
+            "HEAD",
+            "POST",
+            "PUT",
+            "DELETE",
+            "CONNECT",
+            "OPTIONS",
+            "TRACE",
+            "PATCH"
+        ];
+        if (value && !methods.includes(value)) throw new Error("Not valid method value!");
+        _class_private_field_set(this, _method, value || null);
+    }
+    getQueryParameters() {
+        return _class_private_field_get(this, _queryParameters);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getQueryArray(value) {
+        var _value_replace;
+        if (typeof value === "string") return value === null || value === void 0 ? void 0 : (_value_replace = value.replace(/\?/g, "")) === null || _value_replace === void 0 ? void 0 : _value_replace.split("&");
+        else if (Array.isArray(value)) return value.map((item)=>item.replace(/\?/g, ""));
+        else if (typeof value === "object" && value !== null) return Object.keys(value).filter((key)=>key && value[key]).map((key)=>`${key}=${value[key]}`);
+        else return [];
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getQueryString(value) {
+        if (!Array.isArray(value)) throw new Error("Not valid query parameters value!");
+        return value.length ? `?${value.join("&")}` : "";
+    }
+    setQueryParameters(value) {
+        if (value && !Array.isArray(value)) throw new Error("Not valid query parameters value!");
+        _class_private_field_set(this, _queryParameters, value || null);
+    }
+    getHeaders() {
+        return _class_private_field_get(this, _headers);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getHeadersObj(value) {
+        const headers = new Headers();
+        if (!value) return headers;
+        if (typeof value !== "object" || Array.isArray(value)) throw new Error("Not valid headers value!");
+        Object.keys(value).forEach((item)=>{
+            headers.append(item, value[item]);
+        });
+        return headers;
+    }
+    setHeaders(value) {
+        if (value && (typeof value !== "object" || Array.isArray(value))) throw new Error("Not valid headers value!");
+        _class_private_field_set(this, _headers, value || null);
+    }
+    getBody() {
+        return _class_private_field_get(this, _body);
+    }
+    setBody(value) {
+        _class_private_field_set(this, _body, value);
+    }
+    getOptions() {
+        return _class_private_field_get(this, _options);
+    }
+    setOptions(value) {
+        if (value && (typeof value !== "object" || Array.isArray(value))) throw new Error("Not valid options value!");
+        _class_private_field_set(this, _options, {
+            ...value
+        });
+    }
+    getCallback() {
+        return _class_private_field_get(this, _callback);
+    }
+    setCallback(value) {
+        if (value && typeof value !== "function") throw new Error("Not valid callback value!");
+        _class_private_field_set(this, _callback, value || null);
+    }
+    getCatchCallback() {
+        return _class_private_field_get(this, _catchCallback);
+    }
+    setCatchCallback(value) {
+        if (value && typeof value !== "function") throw new Error("Not valid callback value!");
+        _class_private_field_set(this, _catchCallback, value || null);
+    }
+    getEveryPromiseCallback() {
+        return _class_private_field_get(this, _everyPromiseCallback);
+    }
+    setEveryPromiseCallback(value) {
+        if (value && typeof value !== "function") throw new Error("Not valid callback value!");
+        _class_private_field_set(this, _everyPromiseCallback, value || null);
+    }
+    getIsResponseAsObject() {
+        return _class_private_field_get(this, _isResponseAsObject);
+    }
+    setIsResponseAsObject(value) {
+        _class_private_field_set(this, _isResponseAsObject, typeof value !== "boolean" && value !== "always" ? Boolean(value) : value);
+    }
+    getProps() {
+        return {
+            pathPrefix: this.getPathPrefix() || null,
+            method: this.getMethod() || null,
+            queryParameters: this.getQueryParameters() || null,
+            headers: this.getHeaders() || null,
+            body: this.getBody() || null,
+            options: this.getOptions() || null,
+            callback: this.getCallback() || null,
+            everyPromiseCallback: this.getEveryPromiseCallback(),
+            // isAnywayRunCallback: this.getIsAnywayRunCallback(),
+            isResponseAsObject: this.getIsResponseAsObject()
+        };
+    }
+    setProps(input) {
+        const { pathPrefix, method, queryParameters, headers, body, options, callback, catchCallback, everyPromiseCallback, // isAnywayRunCallback,
+        isResponseAsObject } = input;
+        if (pathPrefix) this.setPathPrefix(pathPrefix);
+        if (method) this.setMethod(method);
+        if (queryParameters) this.setQueryParameters(this.getQueryArray(queryParameters));
+        if (headers) this.setHeaders(headers);
+        if (body) this.setBody(body);
+        if (options) this.setOptions(options);
+        if (callback) this.setCallback(callback);
+        if (catchCallback) this.setCatchCallback(catchCallback);
+        if (everyPromiseCallback) this.setEveryPromiseCallback(everyPromiseCallback);
+        // if (isAnywayRunCallback) this.setIsAnywayRunCallback(isAnywayRunCallback);
+        if (isResponseAsObject !== undefined) this.setIsResponseAsObject(isResponseAsObject);
+    }
+    constructor(input){
+        _class_private_field_init(this, _pathPrefix, {
+            writable: true,
+            value: null
+        });
+        _class_private_field_init(this, _method, {
+            writable: true,
+            value: null
+        });
+        _class_private_field_init(this, _queryParameters, {
+            writable: true,
+            value: null
+        });
+        _class_private_field_init(this, _headers, {
+            writable: true,
+            value: null
+        });
+        _class_private_field_init(this, _body, {
+            writable: true,
+            value: null
+        });
+        _class_private_field_init(this, _options, {
+            writable: true,
+            value: null
+        });
+        _class_private_field_init(this, _callback, {
+            writable: true,
+            value: null
+        });
+        _class_private_field_init(this, _catchCallback, {
+            writable: true,
+            value: null
+        });
+        _class_private_field_init(this, _everyPromiseCallback, {
+            writable: true,
+            value: null
+        });
+        _class_private_field_init(this, _isResponseAsObject, {
+            writable: true,
+            value: false
+        });
+        if (input && (typeof input !== "object" || Array.isArray(input))) throw new Error("Not valid input value!");
+        this.getPathPrefix = this.getPathPrefix.bind(this);
+        this.setPathPrefix = this.setPathPrefix.bind(this);
+        this.getMethod = this.getMethod.bind(this);
+        this.setMethod = this.setMethod.bind(this);
+        this.getQueryParameters = this.getQueryParameters.bind(this);
+        this.getQueryString = this.getQueryString.bind(this);
+        this.setQueryParameters = this.setQueryParameters.bind(this);
+        this.getHeaders = this.getHeaders.bind(this);
+        this.getHeadersObj = this.getHeadersObj.bind(this);
+        this.setHeaders = this.setHeaders.bind(this);
+        this.getBody = this.getBody.bind(this);
+        this.setBody = this.setBody.bind(this);
+        this.getOptions = this.getOptions.bind(this);
+        this.setOptions = this.setOptions.bind(this);
+        this.getCallback = this.getCallback.bind(this);
+        this.setCallback = this.setCallback.bind(this);
+        this.getCatchCallback = this.getCatchCallback.bind(this);
+        this.setCatchCallback = this.setCatchCallback.bind(this);
+        this.getEveryPromiseCallback = this.getEveryPromiseCallback.bind(this);
+        this.setEveryPromiseCallback = this.setEveryPromiseCallback.bind(this);
+        this.getIsResponseAsObject = this.getIsResponseAsObject.bind(this);
+        this.setIsResponseAsObject = this.setIsResponseAsObject.bind(this);
+        this.getProps = this.getProps.bind(this);
+        this.setProps = this.setProps.bind(this);
+        this.request = this.request.bind(this);
+        this.repeatRequest = this.repeatRequest.bind(this);
+        this.setProps(input || {});
+    }
+}
+const _default = AbortableFetch;

package/dist/src/Classes/AnimatedHandler.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const DEFAULT_ANIMATION_DURATION = 200;
+class AnimatedHandler {
+    constructor(params){
+        const { type = "", animationTarget, animation, settings, hendler } = params || {};
+        if (!animationTarget || !hendler) throw new Error("Bad input!");
+        const { keyframes, delay, direction, duration, easing, endDelay, fill, iterationStart, iterations } = animation || {};
+        // eslint-disable-next-line no-constructor-return
+        return function(...args) {
+            const keyframesToUse = Array.isArray(keyframes) ? keyframes : [
+                {
+                    height: `${animationTarget.clientHeight}px`,
+                    opacity: 1
+                },
+                {
+                    height: "0",
+                    opacity: 0
+                }
+            ];
+            const durationToUse = duration || DEFAULT_ANIMATION_DURATION;
+            animationTarget.animate(keyframesToUse, animation);
+            return new Promise((res)=>{
+                setTimeout(()=>res(hendler ? hendler(...args) : undefined), durationToUse);
+            });
+        };
+    }
+}
+const _default = AnimatedHandler;

package/dist/src/Classes/RESTAPI/index.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _ApiBase = /*#__PURE__*/ _interop_require_default(require("./partials/ApiBase"));
+const _CredentialsProcessing = /*#__PURE__*/ _interop_require_default(require("./partials/CredentialsProcessing"));
+const _utils = require("./partials/_utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function returnTheContext() {
+    return this;
+}
+class RESTAPI extends _ApiBase.default {
+    //! Основной (базовый) метод API, мультизапросы
+    async doRequest(inputRequests, settings) {
+        if (typeof inputRequests !== "string" && typeof inputRequests !== "object") {
+            return Promise.reject(new Error(this.BAD_REQUEST_DATA_TEXT));
+        }
+        //? К свойствам и методам API будем тянуться через замыкания
+        const API_CONTEXT = this;
+        const { isResponseAsObject, isGetBody, callback, ...partialRestSettings } = settings || {};
+        const isGetBodyFirst = isGetBody && isGetBody === "first";
+        const { commonSuccessMessage: CSMfromSettings, commonErrorMessage: CEMfromSettings, successMessageType: SMTfromSettings, isToastResult: isToastFromSettings, toastOptions: TOFomSettings, isNoToastSuccess: isNTSFromSettings, isNoToastError: isNTEFromSettings, isNoToast: isNoToastFromSettings, successMessages, errorMessages } = partialRestSettings || {};
+        //? При вызове getRequestInstance передадим контекст API
+        //? В результате вызова получим экземпляр класса AbortableFetch...
+        const instance = await _utils.getInstanceOfFetchSystem.call(this);
+        if (!instance) {
+            throw new Error('It is impossible to make a request!');
+        }
+        //? ... который еще немного донастроим сеттерами экзепляра
+        instance.setIsResponseAsObject(isResponseAsObject !== null && isResponseAsObject !== void 0 ? isResponseAsObject : true);
+        if (callback) instance.setCallback(callback);
+        //? Это НЕ асинхронная ф-я, которая вернет массив промисов
+        function getRequests() {
+            let output;
+            if (typeof inputRequests === "string") output = [
+                {
+                    path: inputRequests
+                }
+            ];
+            else output = Array.isArray(inputRequests) ? inputRequests : [
+                inputRequests
+            ];
+            //? Это НЕ асинхронная ф-я, которая возвращает асинхронный колбэк
+            function getCallback(item, mesageOptions) {
+                const { getBodyAs } = item;
+                const finalIsGetBody = typeof item.isGetBody === 'boolean' || typeof item.isGetBody === 'string' ? item.isGetBody : isGetBody;
+                const finalIsGetBodyFirst = finalIsGetBody === 'first';
+                const checkResponseCallback = finalIsGetBodyFirst ? async (res, mesageOptions)=>API_CONTEXT.getResponseBody(await API_CONTEXT.checkResponseCode(res, mesageOptions), getBodyAs) : async (res, mesageOptions)=>API_CONTEXT.checkResponseCode(res, mesageOptions);
+                const callback = item.callback ? async (res)=>item.callback(await checkResponseCallback(res, mesageOptions)) : async (res)=>checkResponseCallback(res, mesageOptions);
+                return finalIsGetBody && !finalIsGetBodyFirst ? async (res)=>API_CONTEXT.getResponseBody(await callback(res), getBodyAs) : callback;
+            }
+            async function getRequestItem(item, idx) {
+                const { type, ...partialRestFirst } = item;
+                //? Предполагалось что пропа type в объекте описания запроса
+                //? будет использоваться исключительно для метода doMonoRequest,
+                //? однако оказалось, что type удобно использовать и в мульти запросах (опционально).
+                //? В данном месте происходит обработка type для объектов описания запроса из мульти запроса.
+                //? 'doRequestMapping' - ключ для управления выходными структурами из метода splitProperties
+                //? (splitProperties используется ЛЮБЫМ крейтером)
+                const itemAfterRequestCreating = await API_CONTEXT[`createRequest_${type !== null && type !== void 0 ? type : "default"}`](partialRestFirst, "doRequestMapping");
+                const { fullPath, api, path, query, queryParameters, ...partialRestSecond } = itemAfterRequestCreating;
+                const { successMess, commonSuccessMessage, successMessageType, errorMess, commonErrorMessage, isToastResult, toastOptions, isNoToastSuccess, isNoToastError, isNoToast, ...rest } = partialRestSecond;
+                const useSuccessMessageFlag = Boolean(successMess || commonSuccessMessage || (successMessages === null || successMessages === void 0 ? void 0 : successMessages[idx]) || CSMfromSettings || isToastResult || isToastFromSettings);
+                const isUseSuccessToast = useSuccessMessageFlag && !isNoToast && !isNoToastFromSettings && !isNoToastSuccess && !isNTSFromSettings;
+                const isUseErrorToast = !isNoToast && !isNoToastFromSettings && !isNoToastError && !isNTEFromSettings;
+                const mesageOptions = {
+                    successMess: successMess || commonSuccessMessage || (successMessages === null || successMessages === void 0 ? void 0 : successMessages[idx]) || CSMfromSettings,
+                    successMessageType: successMessageType || SMTfromSettings,
+                    errorMess: errorMess || commonErrorMessage || (errorMessages === null || errorMessages === void 0 ? void 0 : errorMessages[idx]) || CEMfromSettings,
+                    isUseSuccessToast,
+                    isUseErrorToast,
+                    toastOptions: toastOptions || TOFomSettings
+                };
+                //? Данная ф-я асинхронная, пользуемся await-ми чтобы дождаться фактических значений
+                return {
+                    ...rest,
+                    path: `${fullPath || await API_CONTEXT.getRootPath(api) + (path || "")}`,
+                    //? Запускаем самовызывающуюся асинхронную ф-ю, ждем резолва промиса от нее
+                    queryParameters: await (async ()=>{
+                        const queryParams = query || queryParameters || "";
+                        //? Т.к.самовызывающаяся ф-я асинхронная, то можем дождаться фактического значения
+                        const preparedQueryParams = await API_CONTEXT.processQueryParams(queryParams);
+                        return preparedQueryParams;
+                    })(),
+                    mesageOptions,
+                    callback: getCallback(itemAfterRequestCreating, mesageOptions)
+                };
+            }
+            //? getRequestItem - асинхронная ф-я (вызов возвращает промис)
+            //? Вызываем для каждой итерации мапинга, получаем массив промисов
+            return output === null || output === void 0 ? void 0 : output.map((item, idx)=>getRequestItem(item, idx));
+        }
+        //? Ф-я getRequests НЕ асинхронная, но возвращает массив промисов
+        //? ДОЖИДАЕМСЯ резолва всех промисов через Promise.all,
+        //? после резолва всех промисов Promise.all вернет массив результатов резолва,
+        //? instance - экземпляр AbortableFetch
+        //? Вызываем instance.request, передавая массив результатов резолвов промисов
+        //? (т.е. массив объектов описания запроса)
+        return instance.request(await Promise.all(getRequests()));
+    }
+    //! Метод API для одиночных запросов
+    async doMonoRequest(requestSettings) {
+        if (!(0, _utils.getIsOnlyAnObject)(requestSettings)) throw new Error(`${this.BAD_REQUEST_DATA_TEXT} [RESTAPI.doMonoRequest]`);
+        const { type, ...requestSettingsRest } = requestSettings;
+        //? Реквест-крейтеры разделяют параметры, при надобности эти параметры конфигурируют, добавляют ф-ть
+        //? и возвращают массив подготовленных аргументов для метода doRequest
+        const doRequestArgs = type && this[`createRequest_${type}`] ? [
+            ...await this[`createRequest_${type}`](requestSettingsRest)
+        ] : [
+            ...await this.createRequest_default(requestSettingsRest)
+        ];
+        return this.doRequest(...doRequestArgs);
+    }
+    constructor(settings){
+        super(settings);
+        const { sendMessage, credentialsProcessing } = settings || {};
+        this.sendMessage = typeof sendMessage === "function" ? sendMessage : null;
+        //! Наличие credentialsProcessing подключает ДОБАВЛЕНИЕ ТОКЕНОВ В ЗАПРОСЫ,
+        //! НО по умолчанию НЕ добавляет флоу рефреша токенов
+        //! (флоу рефреша подключается пропой isUseRefreshTokensPropcessing из credentialsProcessing)
+        if ((0, _utils.getIsOnlyAnObject)(credentialsProcessing)) {
+            this.credentialsProcessing = new _CredentialsProcessing.default(settings);
+            //? credentialsProcessing расположен обособлено для того, чтобы обладать своим независимым this
+            //? Однако при описании методов credentialsProcessing
+            //? может понадобится воспользоваться непосредственными методами класса RESTAPI
+            //? Для этого предоставляю возможность дотянуться до верхнего контекста
+            this.credentialsProcessing.getRESTAPIContext = returnTheContext.bind(this);
+        }
+    }
+}
+const _default = RESTAPI;