intelicoreact 1.5.32 → 1.5.34

package/dist/src/Classes/RESTAPI/partials/ApiUtils.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _Utils = /*#__PURE__*/ _interop_require_default(require("./Utils"));
+const _utils = require("./_utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class ApiUtils extends _Utils.default {
+    //? Планируется, что метод будет использоваться неизменно, однако технически его можно перегрузить на экземпляре
+    //? Метод не планировался как асинхронный,
+    //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+    async splitProperties(apiParams, variant) {
+        const { isResponseAsObject, isGetBody, finalCallback, isToastResult, toastOptions, isNoToastSuccess, isNoToastError, isNoToast, successMess, commonSuccessMessage, successMessages, successMessageType, errorMess, commonErrorMessage, errorMessages, ...restParams } = apiParams || {};
+        switch(variant){
+            case "doRequestMapping":
+                return {
+                    ...restParams,
+                    isGetBody,
+                    isToastResult,
+                    toastOptions,
+                    isNoToastSuccess,
+                    isNoToastError,
+                    isNoToast,
+                    successMess,
+                    commonSuccessMessage,
+                    successMessages,
+                    successMessageType,
+                    errorMess,
+                    commonErrorMessage,
+                    errorMessages
+                };
+            default:
+                return [
+                    restParams,
+                    {
+                        isGetBody,
+                        isResponseAsObject,
+                        ...finalCallback ? {
+                            callback: finalCallback
+                        } : {},
+                        isToastResult,
+                        toastOptions,
+                        isNoToastSuccess,
+                        isNoToastError,
+                        isNoToast,
+                        commonSuccessMessage: successMess || commonSuccessMessage,
+                        successMessages,
+                        successMessageType,
+                        commonErrorMessage: errorMess || commonErrorMessage,
+                        errorMessages
+                    }
+                ];
+        }
+    }
+    //! Обработчик пропы api из объекта описания запроса
+    //? Планируется, что метод будет перегружаться на экземпляре,
+    //? т.к. на разных проектах могут быть разные интерпретации пропы api
+    //? Метод не планировался как асинхронный,
+    //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+    async getRootPath() {
+        return this.API_PATH;
+    }
+    //? Планируется, что метод будет использоваться неизменно, однако технически его можно перегрузить на экземпляре
+    //? Метод планировался как асинхронный
+    async getResponseBody(response, getBodyAs) {
+        //? Если response не экземпляр Response, то вернуть по факту
+        if (!(response instanceof Response)) return response;
+        //? В этом месте все методы должны быть, т.к. response точно экземпляр Response.
+        //? А вот contentType-а походу может не быть. Наверное...
+        const contentType = response.headers.get("content-type");
+        if (!contentType) return "";
+        // ToDo - ошибка была в получении executor-а...
+        // ToDo - Все было через if. В случае, если не попадало ни в одну if-ку, то возвращался undefined по умолчанию,
+        // ToDo - а после этот undefined пытался запустить через call...
+        const executor = (()=>{
+            if (typeof getBodyAs === 'string' && getBodyAs in response && typeof response[getBodyAs] === 'function') {
+                return response[getBodyAs];
+            }
+            if (typeof contentType === 'string' && contentType.includes('text/csv')) {
+                return response.blob;
+            }
+            return typeof contentType === 'string' && contentType.includes('json') ? response.json : response.text;
+        })();
+        // обработка случаев краша метода json при отсутствии тела ответа
+        try {
+            return await executor.call(response);
+        } catch (e) {
+            //? думаю стоит знать места, где ожидалось тело, а бэк его не положил
+            // eslint-disable-next-line no-console
+            console.log("Failed to extract the body");
+            return null;
+        }
+    }
+    //! Обработчик структуры для ошибки (не рендер месседжа, а имеено формирование ошибки),
+    //? Планируется, что метод будет перегружаться на экземпляре,
+    //? т.к. на разных проектах могут быть разные структуры тела ответа для ошибки
+    //? Метод не планировался как асинхронный,
+    //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+    //? res - уже тело ответа
+    async getErrorMessage(res) {
+        return res;
+    }
+    //? Планируется, что метод будет использоваться неизменно, однако технически его можно перегрузить на экземпляре
+    //? Метод планировался как асинхронный
+    async checkResponseCode(res, settings) {
+        //! При получении экземпляра, если sendMessage не является ф-ей,
+        //! то это воспринимается как отключение шага информирования об ошибке запроса как такового
+        if (typeof this.sendMessage !== "function") return res;
+        const { successMess, errorMess } = settings || {};
+        const message = res.ok ? successMess || this.DEFAULT_SUCCESS_MESSAGE : errorMess || this.getErrorMessage(await this.getResponseBody(await (0, _utils.getResponseClone)(res)));
+        this.sendMessage(message, settings, await (0, _utils.getResponseClone)(res));
+        return res;
+    }
+    //? Суть метода:
+    //? передать из вне структуры, которые будут использоваться для КАЖДОГО запроса сделанного экземпляром RESTAPI
+    //! Данные затрут прочие настройки КРОМЕ данных по логике авторизации
+    //? Планируется, что метод будет перегружаться на экземпляре
+    //? Метод не планировался как асинхронный,
+    //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+    async addAsCommon() {
+        //! Планируемая структура { headers, queryParameters, options }, где
+        //!   - headers и options - объекты,
+        //!   - queryParameters - строка, массив или объект
+        return {};
+    }
+    //! Обработчик квери-параметров для общего процессинга,
+    //! Например для кодирования decodeURIComponent или/и приведения в формат массива
+    //? Планируется, что метод будет перегружаться на экземпляре,
+    //? т.к. на разных проектах могут быть разные договоренности по форматам
+    //? Метод не планировался как асинхронный,
+    //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+    async processQueryParams(queryParams) {
+        return queryParams;
+    }
+    constructor(settings){
+        super();
+        const { utils } = settings || {};
+        if ((0, _utils.getIsOnlyAnObject)(utils)) _utils.addCustomMethods.call(this, utils);
+    }
+}
+const _default = ApiUtils;

package/dist/src/Classes/RESTAPI/partials/CredentialsProcessing.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _outerDependencies = /*#__PURE__*/ _interop_require_default(require("./_outerDependencies"));
+const _utils = require("./_utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const { jwt } = _outerDependencies.default;
+class CredentialsProcessing {
+    getIsTokenStartRefresh() {
+        return localStorage.getItem(this.REFRESH_TOKEN_FLAG);
+    }
+    setIsTokenStartRefresh() {
+        localStorage.setItem(this.REFRESH_TOKEN_FLAG, true);
+    }
+    removeIsTokenStartRefresh() {
+        localStorage.removeItem(this.REFRESH_TOKEN_FLAG);
+    }
+    async getCredentials(isCatchCallbackProcess, callback) {
+        let credentials = await this.getCredentialsByOuter();
+        if (typeof this.importCredentials === "function") credentials = await this.importCredentials(credentials);
+        if (!(0, _utils.getIsOnlyAnObject)(credentials)) credentials = {};
+        const token = credentials.token || null;
+        if (token && !isCatchCallbackProcess) {
+            let decoded;
+            try {
+                decoded = jwt.decode(token);
+            } catch (e) {
+                decoded = null;
+            }
+            const currentTime = Date.now() / 1000;
+            if (decoded !== null && Number(decoded.exp) < currentTime) credentials = {
+                ...credentials,
+                isNeedRefresh: true
+            };
+        }
+        if (callback) await callback({
+            ...credentials,
+            isCatchCallbackProcess
+        });
+        return {
+            ...credentials,
+            isCatchCallbackProcess
+        };
+    }
+    async refreshCredentials(currentCredentials, callback) {
+        const CONTEXT = this;
+        async function finalize(cred) {
+            if (callback) await callback(cred);
+            return Promise.resolve(cred).then(async (res)=>{
+                CONTEXT.removeIsTokenStartRefresh();
+                return res;
+            });
+        }
+        if (!(currentCredentials === null || currentCredentials === void 0 ? void 0 : currentCredentials.token) || !(currentCredentials === null || currentCredentials === void 0 ? void 0 : currentCredentials.refreshToken)) return finalize(CONTEXT.DEFAULT_CREDENTIALS);
+        //! ВНИМАНИЕ! Данный механизм рефреша принят на проекте finturfreactfrontend (админка)
+        //! На кабинете он ТОЧНО НЕ ТАКОЙ
+        async function refreshCredentialsByDefault() {
+            const { token, refreshToken } = currentCredentials;
+            const headers = new Headers();
+            headers.append(...Object.entries(CONTEXT.getHeadersForAuthorize(token)));
+            const body = new FormData();
+            body.append("grant_type", "refresh_token");
+            body.append("refresh_token", refreshToken);
+            body.append("client_id", "oauth");
+            body.append("client_secret", "secret");
+            body.append("access_type", "offline");
+            return fetch(`${CONTEXT.REFRESH_TOKEN_PATH}`, {
+                mode: "cors",
+                method: "POST",
+                headers,
+                body,
+                redirect: "follow"
+            });
+        }
+        //? Передавайте собственный refreshCredentials при получении экземляра RESTAPI, если не уверены,
+        //? что механизм рефреша токенов ИМЕННО ТАКОЙ как в ф-и refreshCredentialsByDefault!
+        //! currentCredentials передаются в формате класса! ({ token, refreshToken, expires })
+        const newCredentials = typeof CONTEXT.refreshCredentialsByOuter === "function" ? await CONTEXT.refreshCredentialsByOuter(currentCredentials) : await refreshCredentialsByDefault();
+        return finalize(newCredentials);
+    }
+    async waitRefresh(isNeedRefresh) {
+        return new Promise((resolve)=>{
+            if (!this.getIsTokenStartRefresh()) {
+                if (isNeedRefresh) this.setIsTokenStartRefresh();
+                resolve();
+            } else {
+                const intervalId = setInterval(()=>{
+                    if (!this.getIsTokenStartRefresh()) {
+                        clearInterval(intervalId);
+                        resolve();
+                    }
+                }, this.INTERVAL_FOR_CHECKING_TOKEN_UPDATE);
+            }
+        });
+    }
+    async processCredentials(cred) {
+        if (!cred.isNeedRefresh && !cred.isCatchCallbackProcess) return cred;
+        const CONTEXT = this;
+        return CONTEXT.refreshCredentials(cred, (response)=>CONTEXT.saveCredentials(response)).then(()=>{
+            return new Promise((resolve)=>{
+                setTimeout(async ()=>{
+                    const newCredentials = await CONTEXT.getCredentials();
+                    if (!(newCredentials === null || newCredentials === void 0 ? void 0 : newCredentials.token)) {
+                        newCredentials.isRefreshFailed = true;
+                        setTimeout(()=>{
+                            var _CONTEXT_callbackAfterRejectRefresh;
+                            CONTEXT === null || CONTEXT === void 0 ? void 0 : (_CONTEXT_callbackAfterRejectRefresh = CONTEXT.callbackAfterRejectRefresh) === null || _CONTEXT_callbackAfterRejectRefresh === void 0 ? void 0 : _CONTEXT_callbackAfterRejectRefresh.call(CONTEXT);
+                        }, 0);
+                    }
+                    resolve(newCredentials);
+                }, 0);
+            });
+        });
+    }
+    constructor(settings){
+        const { credentialsProcessing } = settings;
+        const { //? Для корректной работы установки токенов в запросы от API
+        //? нужно передавать методы getCredentials и getHeadersForAuthorize
+        getCredentials, getHeadersForAuthorize, //? Так же опционально можно передавать
+        importCredentials, saveCredentials, //! Либо вызов getCredentials, либо цепочка вызовов importCredentials(getCredentials())
+        //! должна возвращать требуемую классом структуру
+        //! Класс требует структуры
+        //!   - { token }, если флоу рефреш токена НЕ используется
+        //!   - { token, refreshToken, expires }, если используется флоу рефреш токена
+        // *********
+        //? Подключает флоу рефреша токенов
+        isUseRefreshTokensPropcessing = false, //! Для корректной работы флоу рефреша токенов передача метода saveCredentials становится ОБЯЗАТЕЛЬНОЙ
+        //? Так же для корректной работы флоу рефреша токенов нужно
+        //?   - либо
+        refreshCredentials, //? на вход получит текущие креды, к выходу будет применен importCredentials, если этот метод передавался
+        //?   - либо
+        REFRESH_TOKEN_PATH, CODES_USING_THE_REFRESH_ATTEMPT, //? Опционально
+        REFRESH_TOKEN_FLAG = "refreshTokenFlag", INTERVAL_FOR_CHECKING_TOKEN_UPDATE = 50, callbackAfterRejectRefresh } = credentialsProcessing || {};
+        if (typeof getCredentials !== "function") throw new Error("No getCredentials method [CredentialsProcessing]");
+        if (typeof getHeadersForAuthorize !== "function") {
+            throw new Error("No getHeadersForAuthorize method [CredentialsProcessing]");
+        }
+        if (importCredentials && typeof importCredentials !== "function") {
+            throw new Error("Bad importCredentials method [CredentialsProcessing]");
+        }
+        this.isUseRefreshTokensPropcessing = isUseRefreshTokensPropcessing;
+        this.DEFAULT_CREDENTIALS = {};
+        this.getCredentialsByOuter = getCredentials;
+        this.getHeadersForAuthorize = getHeadersForAuthorize;
+        this.importCredentials = importCredentials;
+        //? Если метод передан или если не передан, но включен флоу обновления токенов (тогда saveCredentials обязателен)
+        if (saveCredentials || isUseRefreshTokensPropcessing) {
+            if (typeof saveCredentials !== "function") throw new Error("No saveCredentials method [CredentialsProcessing]");
+            else this.saveCredentials = saveCredentials;
+        }
+        if (isUseRefreshTokensPropcessing) {
+            if (typeof refreshCredentials === "function") this.refreshCredentialsByOuter = refreshCredentials;
+            else {
+                if (typeof this.refreshCredentialsByOuter === "function" && typeof REFRESH_TOKEN_PATH !== "string") {
+                    throw new Error("No REFRESH_TOKEN_PATH [CredentialsProcessing]");
+                }
+                this.REFRESH_TOKEN_PATH = REFRESH_TOKEN_PATH;
+            }
+            if (!Array.isArray(CODES_USING_THE_REFRESH_ATTEMPT)) {
+                throw new Error("No CODES_USING_THE_REFRESH_ATTEMPT [CredentialsProcessing]");
+            }
+            if (!CODES_USING_THE_REFRESH_ATTEMPT.every((i)=>typeof i === "number")) {
+                throw new Error("Invalid format of CODES_USING_THE_REFRESH_ATTEMPT elements [CredentialsProcessing]");
+            }
+            if (typeof REFRESH_TOKEN_FLAG !== "string") throw new Error("Bad REFRESH_TOKEN_FLAG [CredentialsProcessing]");
+            if (typeof INTERVAL_FOR_CHECKING_TOKEN_UPDATE !== "number") {
+                throw new Error("Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE [CredentialsProcessing]");
+            }
+            if (typeof INTERVAL_FOR_CHECKING_TOKEN_UPDATE !== "number") {
+                throw new Error("Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE [CredentialsProcessing]");
+            }
+            if (callbackAfterRejectRefresh && typeof callbackAfterRejectRefresh !== "function") {
+                throw new Error("Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE [CredentialsProcessing]");
+            }
+            this.CODES_USING_THE_REFRESH_ATTEMPT = CODES_USING_THE_REFRESH_ATTEMPT;
+            this.REFRESH_TOKEN_FLAG = REFRESH_TOKEN_FLAG;
+            this.INTERVAL_FOR_CHECKING_TOKEN_UPDATE = INTERVAL_FOR_CHECKING_TOKEN_UPDATE;
+            if (callbackAfterRejectRefresh) this.callbackAfterRejectRefresh = callbackAfterRejectRefresh;
+        }
+    }
+}
+const _default = CredentialsProcessing;

package/dist/src/Classes/RESTAPI/partials/Utils.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _utils = require("./_utils");
+//? В этом кклассе собраны полезные добавочные утилиты, которые могут быть использованы другими классами,
+//? но не имеют прямого отношения к реализации прямой ф-ти RESTAPI
+//? Так же утилиты могут быть использованы как библиотечные
+class Utils {
+    //! Могут содержаться НЕасинхронные методы!
+    //? Ф-я normalizeQueryParams является нормализатором сложных квери
+    //? Например: &key1=&&&===&&&key2====&&&&&&&&key3=....
+    //? Для корректной работы на вход нужно подавать НЕ кодированные значения
+    //? По умолчанию выходные значения квери-параметров НЕ кодируются
+    normalizeQueryParams(queryParams, settings) {
+        if (settings && !(0, _utils.getIsOnlyAnObject)(settings)) {
+            throw new Error("Bad settings [class Utils, normalizeQueryParams]");
+        }
+        const getInitialArr = (input)=>{
+            const prepareParam = (key, value)=>{
+                if (!value) return `${key}=`;
+                else if (typeof value === "string" || typeof value === "number") return `${key}=${value}`;
+                else if (Array.isArray(value)) return `${key}=${value.join("")}`;
+                else return `${key}=Bad-data-format`;
+            };
+            if (Array.isArray(input)) {
+                return input.map((item)=>{
+                    if (typeof item !== "string") return [];
+                    const index = item.indexOf("=");
+                    if (index === -1) return [
+                        item
+                    ];
+                    return [
+                        item.slice(0, index),
+                        item.slice(index + 1)
+                    ];
+                }).filter(([key])=>Boolean(key)).map(([key, value])=>prepareParam(key, value));
+            } else if ((0, _utils.getIsOnlyAnObject)(input)) return Object.keys(input).map((key)=>prepareParam(key, input[key]));
+            else if (typeof input === "string") return (input[0] === "?" ? input.slice(1) : input).split("&");
+            else return [];
+        };
+        const { isEncode = false, outputAs = "array" } = settings || {};
+        const initialStructure = getInitialArr(queryParams);
+        const normalizedStructure = initialStructure.reduce((acc, str, idx)=>{
+            const lastIndex = acc.result.length - 1;
+            const processToJoin = (val, recoverableSymbol = "&")=>{
+                const encodedToJoin = `${encodeURIComponent(recoverableSymbol)}${encodeURIComponent(val)}`;
+                acc.result[lastIndex] = `${acc.result[lastIndex]}${encodedToJoin}`;
+                acc.toJoin = null;
+            };
+            if (typeof acc.toJoin === "string") processToJoin(acc.toJoin);
+            const index = str.indexOf("=");
+            if (index !== -1 && index !== 0) {
+                const key = str.slice(0, index);
+                acc.result.push(`${key}=${encodeURIComponent(str.slice(index + 1))}`);
+            } else acc.toJoin = str;
+            //? Добивка для последней итерации
+            if (idx === initialStructure.length - 1 && typeof acc.toJoin === "string") processToJoin(acc.toJoin);
+            return acc;
+        }, {
+            result: [],
+            toJoin: null
+        }).result;
+        const outputStructure = normalizedStructure.map((item)=>{
+            const [key, value] = item.split("=");
+            return [
+                key,
+                !isEncode ? decodeURIComponent(value) : value
+            ];
+        });
+        switch(outputAs){
+            case "string":
+                return outputStructure.length ? `?${outputStructure.map(([key, value])=>`${key}=${value}`).join("&")}` : "";
+            case "object":
+                return outputStructure.reduce((acc, [key, value])=>({
+                        ...acc,
+                        [key]: value
+                    }), {});
+            default:
+                return outputStructure.map(([key, value])=>`${key}=${value}`);
+        }
+    }
+}
+const _default = Utils;

package/dist/src/Classes/RESTAPI/partials/_outerDependencies.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _jsonwebtoken = /*#__PURE__*/ _interop_require_default(require("jsonwebtoken"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const _default = {
+    jwt: _jsonwebtoken.default
+};

package/dist/src/Classes/RESTAPI/partials/_utils.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    addCustomMethods: function() {
+        return addCustomMethods;
+    },
+    clone: function() {
+        return clone;
+    },
+    getInstanceOfFetchSystem: function() {
+        return getInstanceOfFetchSystem;
+    },
+    getIsOnlyAnObject: function() {
+        return getIsOnlyAnObject;
+    },
+    getResponseClone: function() {
+        return getResponseClone;
+    },
+    omitKeys: function() {
+        return omitKeys;
+    }
+});
+const _AbortableFetch = /*#__PURE__*/ _interop_require_default(require("./AbortableFetch"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getIsOnlyAnObject(input) {
+    return typeof input === "object" && input instanceof Object && !Array.isArray(input);
+}
+const clone = (input)=>{
+    if (input === null || typeof input !== "object") return input;
+    const data = input instanceof Array ? [] : {};
+    for(const i in input)data[i] = clone(input[i]);
+    return data;
+};
+const omitKeys = (obj = {}, keys = [])=>keys.reduce((acc, key)=>{
+        const { [key]: omit, ...rest } = acc;
+        return rest;
+    }, obj);
+const getResponseClone = async (res)=>typeof (res === null || res === void 0 ? void 0 : res.clone) === "function" ? await res.clone() : clone(res);
+function addCustomMethods(data, prefix) {
+    const preparedPrefix = (prefix || "").toString();
+    Object.keys(data).forEach((key)=>{
+        const preparedKey = `${preparedPrefix}${key}`;
+        if (typeof data[key] === "function" && getIsOnlyAnObject(this)) this[preparedKey] = data[key];
+    });
+}
+async function getInstanceOfFetchSystem(isGetBody) {
+    var _API_CONTEXT_addAsCommon;
+    const API_CONTEXT = this;
+    const CREDENTIALS_CONTEXT = API_CONTEXT.credentialsProcessing;
+    let credentials = {};
+    //? Наличие credentialsProcessing включает добавление токена в принципе (если авторизованы в системе)
+    if (CREDENTIALS_CONTEXT) {
+        //? Метод getCredentials - классовый метод, обертка над getCredentials, переданным при создании экземпляра
+        //? В классовом getCredentials уже инкапсулирована логика использования importCredentials
+        const cred = await CREDENTIALS_CONTEXT.getCredentials();
+        credentials = CREDENTIALS_CONTEXT.isUseRefreshTokensPropcessing ? await CREDENTIALS_CONTEXT.waitRefresh(cred.isNeedRefresh && !CREDENTIALS_CONTEXT.getIsTokenStartRefresh()).then(async ()=>CREDENTIALS_CONTEXT.processCredentials(await CREDENTIALS_CONTEXT.getCredentials())) : cred;
+    }
+    //? На уровне получения instance может уже сложиться ситуация, что сходили на рефреш и он неудачный.
+    //? Прерываем получение instance, даем возможность отработать callbackAfterRejectRefresh (смотри class CredentialsProcessing)
+    if (credentials.isRefreshFailed) return null;
+    if (API_CONTEXT.addAsCommon && typeof API_CONTEXT.addAsCommon !== "function") {
+        throw new Error("addAsCommon must be function [getInstanceOfFetchSystem]");
+    }
+    const { headers: headersToAbortableFetchInstance, queryParameters: queryParamsToAbortableFetchInstance, options: optionsToAbortableFetchInstance } = await ((_API_CONTEXT_addAsCommon = API_CONTEXT.addAsCommon) === null || _API_CONTEXT_addAsCommon === void 0 ? void 0 : _API_CONTEXT_addAsCommon.call(API_CONTEXT)) || {};
+    if (headersToAbortableFetchInstance && !getIsOnlyAnObject(headersToAbortableFetchInstance) || optionsToAbortableFetchInstance && !getIsOnlyAnObject(optionsToAbortableFetchInstance) || queryParamsToAbortableFetchInstance && !(typeof queryParamsToAbortableFetchInstance === "string" || getIsOnlyAnObject(queryParamsToAbortableFetchInstance) || Array.isArray(queryParamsToAbortableFetchInstance))) {
+        throw new Error("Bad output format from addAsCommon [getInstanceOfFetchSystem]");
+    }
+    //? По итогу возвращается экземпляр класса AbortableFetch (который мы конфигурируем большим объектом настроек)
+    return ((CREDENTIALS_CONTEXT === null || CREDENTIALS_CONTEXT === void 0 ? void 0 : CREDENTIALS_CONTEXT.isUseRefreshTokensPropcessing) ? CREDENTIALS_CONTEXT.waitRefresh() : Promise.resolve()).then(async ()=>{
+        var _CREDENTIALS_CONTEXT_getHeadersForAuthorize;
+        return new _AbortableFetch.default({
+            //? Метод по умолчанию
+            method: "GET",
+            //? Заголовки по умолчанию
+            headers: {
+                ...headersToAbortableFetchInstance,
+                //? (*) Тут обрабатываются кейсы
+                //?   - когда нет this.credentialsProcessing
+                //?     (мы НЕ хотим добавлять токены в принципе, не зашли в верхнюю if-ку)
+                //?   - когда есть this.credentialsProcessing, но нет credentials.token (не авторизованы)
+                //?     (зашли в верхнюю if-ку, попробовали получить/обновить креды)
+                ...credentials.token ? (CREDENTIALS_CONTEXT === null || CREDENTIALS_CONTEXT === void 0 ? void 0 : (_CREDENTIALS_CONTEXT_getHeadersForAuthorize = CREDENTIALS_CONTEXT.getHeadersForAuthorize) === null || _CREDENTIALS_CONTEXT_getHeadersForAuthorize === void 0 ? void 0 : _CREDENTIALS_CONTEXT_getHeadersForAuthorize.call(CREDENTIALS_CONTEXT, credentials.token)) || {} : {}
+            },
+            queryParameters: await API_CONTEXT.processQueryParams(queryParamsToAbortableFetchInstance),
+            //? Опции по умолчанию
+            options: {
+                mode: "cors",
+                redirect: "follow",
+                ...optionsToAbortableFetchInstance
+            },
+            //? Каждый запрос (каждый запрос мультизапроса), сделаный методом request этого экземпляра выполнит этот колбек
+            everyPromiseCallback: async function everyPromiseCallback(response) {
+                var _CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT_includes, _CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT;
+                //? this - это НЕ API_CONTEXT и НЕ CREDENTIALS_CONTEXT, a итоговый эекземпляр AbortableFetch
+                const ABORTABLE_FETCH_INSTANCE = this;
+                if (!response.status) {
+                    var _request_mesageOptions;
+                    const request = ABORTABLE_FETCH_INSTANCE.requestInput.find((item)=>item.path === response.request.path);
+                    const isUseErrorToast = request === null || request === void 0 ? void 0 : (_request_mesageOptions = request.mesageOptions) === null || _request_mesageOptions === void 0 ? void 0 : _request_mesageOptions.isUseErrorToast;
+                    if (isUseErrorToast) {
+                        var _API_CONTEXT_sendMessage;
+                        (_API_CONTEXT_sendMessage = API_CONTEXT.sendMessage) === null || _API_CONTEXT_sendMessage === void 0 ? void 0 : _API_CONTEXT_sendMessage.call(API_CONTEXT, API_CONTEXT.NO_INET, request.mesageOptions, response);
+                    }
+                }
+                return API_CONTEXT.REJECT_CODES.includes(response.status) || (CREDENTIALS_CONTEXT === null || CREDENTIALS_CONTEXT === void 0 ? void 0 : CREDENTIALS_CONTEXT.isUseRefreshTokensPropcessing) && (CREDENTIALS_CONTEXT === null || CREDENTIALS_CONTEXT === void 0 ? void 0 : (_CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT = CREDENTIALS_CONTEXT.CODES_USING_THE_REFRESH_ATTEMPT) === null || _CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT === void 0 ? void 0 : (_CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT_includes = _CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT.includes) === null || _CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT_includes === void 0 ? void 0 : _CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT_includes.call(_CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT, response.status)) ? Promise.reject(new Error(`status:${response.status}`)) : Promise.resolve(!isGetBody ? response : await API_CONTEXT.getResponseBody(response));
+            },
+            //? Если хоть один запрос из пачки будет зареджекчен, зареджектится вся пачка.
+            //? В этом случае будет выполнен этот колбэк
+            catchCallback: async function catchCallback(res) {
+                var _CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT_includes, _CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT;
+                //? this - это НЕ API_CONTEXT и НЕ CREDENTIALS_CONTEXT, a итоговый эекземпляр AbortableFetch
+                const ABORTABLE_FETCH_INSTANCE = this;
+                const code = Number(res.message.split(":")[1]);
+                if (CREDENTIALS_CONTEXT === null || CREDENTIALS_CONTEXT === void 0 ? void 0 : (_CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT = CREDENTIALS_CONTEXT.CODES_USING_THE_REFRESH_ATTEMPT) === null || _CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT === void 0 ? void 0 : (_CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT_includes = _CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT.includes) === null || _CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT_includes === void 0 ? void 0 : _CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT_includes.call(_CREDENTIALS_CONTEXT_CODES_USING_THE_REFRESH_ATTEMPT, code)) {
+                    var _CREDENTIALS_CONTEXT_getIsTokenStartRefresh;
+                    const isDoRefresh = !(CREDENTIALS_CONTEXT === null || CREDENTIALS_CONTEXT === void 0 ? void 0 : (_CREDENTIALS_CONTEXT_getIsTokenStartRefresh = CREDENTIALS_CONTEXT.getIsTokenStartRefresh) === null || _CREDENTIALS_CONTEXT_getIsTokenStartRefresh === void 0 ? void 0 : _CREDENTIALS_CONTEXT_getIsTokenStartRefresh.call(CREDENTIALS_CONTEXT));
+                    return CREDENTIALS_CONTEXT === null || CREDENTIALS_CONTEXT === void 0 ? void 0 : CREDENTIALS_CONTEXT.waitRefresh(isDoRefresh).then(async ()=>{
+                        //? Пробуем зарефрешить
+                        const newCredentials = await (CREDENTIALS_CONTEXT === null || CREDENTIALS_CONTEXT === void 0 ? void 0 : CREDENTIALS_CONTEXT.processCredentials({
+                            ...await (CREDENTIALS_CONTEXT === null || CREDENTIALS_CONTEXT === void 0 ? void 0 : CREDENTIALS_CONTEXT.getCredentials(true)),
+                            isCatchCallbackProcess: isDoRefresh
+                        }));
+                        ABORTABLE_FETCH_INSTANCE.setHeaders({
+                            ...ABORTABLE_FETCH_INSTANCE.getHeaders(),
+                            ...(newCredentials === null || newCredentials === void 0 ? void 0 : newCredentials.token) ? {
+                                Authorization: `Bearer ${newCredentials === null || newCredentials === void 0 ? void 0 : newCredentials.token}`
+                            } : {}
+                        });
+                        if (newCredentials.token) return ABORTABLE_FETCH_INSTANCE.repeatRequest();
+                        return Promise.reject(res);
+                    });
+                }
+                return Promise.reject(res);
+            }
+        });
+    });
+}