intelicoreact 2.0.8 → 2.0.10

package/dist/index.js

@@ -399,7 +399,11 @@ var AnimatedHandler = class {
 };
 var AnimatedHandler_default = AnimatedHandler;
 
-// src/Classes/RESTAPI/partials/AbortableFetch.js
+// src/Classes/RESTAPI/partials/AbortableFetch.ts
+var HTTP_METHODS = ["GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE", "PATCH"];
+function isHttpMethod(value) {
+  return HTTP_METHODS.includes(value);
+}
 var RESPONSE_AS_OBJECT_ALWAYS_VALUE2 = "always";
 var AbortableFetch2 = class {
   #pathPrefix = null;
@@ -412,6 +416,8 @@ var AbortableFetch2 = class {
   #catchCallback = null;
   #everyPromiseCallback = null;
   #isResponseAsObject = false;
+  // ? Последний вход request() — используется repeatRequest() для повторного запроса той же пачки.
+  requestInput = [];
   constructor(input) {
     if (input && !getIsOnlyAnObject(input)) throw new Error("Not valid input value!");
     this.getPathPrefix = this.getPathPrefix.bind(this);
@@ -442,20 +448,30 @@ var AbortableFetch2 = class {
     this.repeatRequest = this.repeatRequest.bind(this);
     this.setProps(input || {});
   }
+  /**
+   * Выполняет один или несколько HTTP-запросов (нативный fetch) с возможностью отмены.
+   *
+   * Метод `abort()` навешивается на прототип возвращаемого промиса (как в исходной реализации),
+   * что позволяет отменить всю цепочку запросов вызовом `abort()` на возвращённом промисе.
+   *
+   * @param props - путь, объект описания запроса или их массив.
+   * @returns Промис с результатом (форма зависит от isResponseAsObject); на прототипе доступен `abort()`.
+   */
   async request(props) {
     if (!getIsOnlyAnObject(props) && !Array.isArray(props) && typeof props !== "string") throw new Error("Not valid props value!");
-    const stringifyBody = (b) => b?.constructor === FormData ? b : JSON.stringify(b);
+    const stringifyBody = (b) => b instanceof FormData ? b : JSON.stringify(b);
     this.requestInput = props;
     const requests = getRequestsArray.call(this, props);
     const ABORTABLE_FETCH_CONTEXT = this;
     const abortController = new AbortController();
     const addProps = (response, request) => {
-      response.request = request;
-      if (ABORTABLE_FETCH_CONTEXT.#isResponseAsObject) response.name = getIsOnlyAnObject(request) ? request.name || "" : "";
-      return response;
+      return Object.assign(response, {
+        request,
+        ...ABORTABLE_FETCH_CONTEXT.#isResponseAsObject ? { name: getIsOnlyAnObject(request) ? request.name || "" : "" } : {}
+      });
     };
-    let externalRequest = Promise.all(
-      requests.map(async (item) => {
+    const externalRequest = Promise.all(
+      requests.map((item) => {
         const safelyQuery = item.path.includes("?") ? `&${item.queryParameters.replace(/\?/g, "")}` : item.queryParameters;
         const internalRequest = fetch(`${item.pathPrefix}${item.path}${safelyQuery}`, {
           ...item.options,
@@ -466,12 +482,15 @@ var AbortableFetch2 = class {
         }).then(async (response) => addProps(response, item)).catch(async (response) => {
           if (response instanceof Response) return Promise.resolve(addProps(response, item));
           return Promise.resolve(
-            addProps({
-              ok: false,
-              status: 0,
-              statusText: response,
-              request: item
-            })
+            addProps(
+              {
+                ok: false,
+                status: 0,
+                statusText: response,
+                request: item
+              },
+              item
+            )
           );
         }).then(async (res) => {
           return typeof ABORTABLE_FETCH_CONTEXT.#everyPromiseCallback === "function" && !item.isSkipEveryPromiseCallback ? await ABORTABLE_FETCH_CONTEXT.#everyPromiseCallback(res) : res;
@@ -480,7 +499,8 @@ var AbortableFetch2 = class {
         }).then(async (res) => {
           return { request: item, response: res, ...item.name ? { name: item.name } : {} };
         });
-        internalRequest.__proto__.abort = () => abortController.abort();
+        const internalProto = Object.getPrototypeOf(internalRequest);
+        internalProto.abort = () => abortController.abort();
         return internalRequest;
       })
     ).then(async (resArr) => {
@@ -488,16 +508,17 @@ var AbortableFetch2 = class {
         return ABORTABLE_FETCH_CONTEXT.#isResponseAsObject ? {} : [];
       }
       if (ABORTABLE_FETCH_CONTEXT.#isResponseAsObject === RESPONSE_AS_OBJECT_ALWAYS_VALUE2) {
-        return resArr.reduce((ac, item) => ({ ...ac, [item.name]: item.response }), {});
+        return resArr.reduce((ac, item) => ({ ...ac, [String(item.name)]: item.response }), {});
       }
       if (resArr.length === 1) return resArr[0].response;
-      return ABORTABLE_FETCH_CONTEXT.#isResponseAsObject === true ? resArr.reduce((ac, item) => ({ ...ac, [item.name]: item.response }), {}) : resArr.map((item) => item.response);
+      return ABORTABLE_FETCH_CONTEXT.#isResponseAsObject === true ? resArr.reduce((ac, item) => ({ ...ac, [String(item.name)]: item.response }), {}) : resArr.map((item) => item.response);
     }).then(async (res) => {
       return typeof ABORTABLE_FETCH_CONTEXT.#callback === "function" ? await ABORTABLE_FETCH_CONTEXT.#callback(res) : res;
     }).catch(async (res) => {
       return typeof ABORTABLE_FETCH_CONTEXT.#catchCallback === "function" ? await ABORTABLE_FETCH_CONTEXT.#catchCallback(res) : res;
     });
-    externalRequest.__proto__.abort = () => abortController.abort();
+    const externalProto = Object.getPrototypeOf(externalRequest);
+    externalProto.abort = () => abortController.abort();
     return externalRequest;
     function getRequestsArray(input) {
       const requestsArray = (() => {
@@ -522,15 +543,17 @@ var AbortableFetch2 = class {
           callback: omitCallback,
           mergeProps: omitMergeProps,
           ...optionsRest
-        } = options || {};
+        } = getIsOnlyAnObject(options) ? options : {};
+        const localMethod = typeof method === "string" && isHttpMethod(method) ? method : null;
+        const localCallback = typeof callback === "function" ? (res) => callback(res) : void 0;
         return [
           ...ac,
           {
             path,
             pathPrefix: getMergeProps("pathPrefix") === "onlyLocal" || isNoPathPrefix ? "" : this.#pathPrefix || "",
             method: (() => {
-              if (getMergeProps("method") === "onlyLocal") return method || "GET";
-              return getMergeProps("method") === "onlyGlobal" ? this.#method || "GET" : method || this.#method || "GET";
+              if (getMergeProps("method") === "onlyLocal") return localMethod || "GET";
+              return getMergeProps("method") === "onlyGlobal" ? this.#method || "GET" : localMethod || this.#method || "GET";
             })(),
             queryParameters: (() => {
               if ((getMergeProps("queryParameters") ?? getMergeProps("query")) === "onlyLocal") {
@@ -539,31 +562,34 @@ var AbortableFetch2 = class {
               return (getMergeProps("queryParameters") ?? getMergeProps("query")) === "onlyGlobal" ? this.getQueryString(this.getQueryArray(this.#queryParameters)) : this.getQueryString([...this.getQueryArray(this.#queryParameters), ...this.getQueryArray(queryParameters)]);
             })(),
             headers: (() => {
-              if (getMergeProps("headers") === "onlyLocal") return this.getHeadersObj(headers || {});
+              if (getMergeProps("headers") === "onlyLocal") return this.getHeadersObj(getIsOnlyAnObject(headers) ? headers : {});
               return getMergeProps("headers") === "onlyGlobal" ? this.getHeadersObj({ ...this.#headers || {} }) : this.getHeadersObj({
                 ...this.#headers || {},
-                ...headers || {}
+                ...getIsOnlyAnObject(headers) ? headers : {}
               });
             })(),
             body: (() => {
               if (getMergeProps("body") === "onlyLocal") return body || null;
               if (getMergeProps("body") === "onlyGlobal") return this.#body || null;
               if (body && this.#body && typeof body === typeof this.#body && typeof body === "object") {
-                return Array.isArray(body) ? [...this.#body, ...body] : { ...this.#body, ...body };
-              } else return body || this.#body || null;
+                return Array.isArray(body) ? [...Array.isArray(this.#body) ? this.#body : [], ...body] : { ...getIsOnlyAnObject(this.#body) ? this.#body : {}, ...getIsOnlyAnObject(body) ? body : {} };
+              } else {
+                return body || this.#body || null;
+              }
             })(),
             options: (() => {
-              if (getMergeProps("options") === "onlyLocal") return { ...optionsRest || {} };
-              return getMergeProps("options") === "onlyGlobal" ? { ...this.#options || {} } : { ...this.#options || {}, ...optionsRest || {} };
+              if (getMergeProps("options") === "onlyLocal") return { ...optionsRest };
+              return getMergeProps("options") === "onlyGlobal" ? { ...this.#options || {} } : { ...this.#options || {}, ...optionsRest };
             })(),
-            callback,
-            isSkipEveryPromiseCallback,
+            callback: localCallback,
+            isSkipEveryPromiseCallback: Boolean(isSkipEveryPromiseCallback),
             ...this.getIsResponseAsObject() ? { name: name && typeof name === "string" ? name : index } : {}
           }
         ];
       }, []);
     }
   }
+  /** Повторяет последний выполненный запрос (ту же пачку). */
   repeatRequest() {
     return this.request(this.requestInput);
   }
@@ -579,19 +605,23 @@ var AbortableFetch2 = class {
     return 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!");
+    if (value && !isHttpMethod(value)) throw new Error("Not valid method value!");
     this.#method = value || null;
   }
   getQueryParameters() {
     return this.#queryParameters;
   }
   getQueryArray(value) {
-    if (typeof value === "string") return (value[0] === "?" ? value.slice(1) : value).split("&");
-    else if (Array.isArray(value)) return value;
-    else if (typeof value === "object" && value !== null) {
-      return Object.keys(value).filter((key) => Boolean(key) && Boolean(value[key])).map((key) => `${key}=${value[key]}`);
-    } else return [];
+    if (typeof value === "string") {
+      return (value[0] === "?" ? value.slice(1) : value).split("&");
+    } else if (Array.isArray(value)) {
+      return value.map((item) => `${item}`);
+    } else if (typeof value === "object" && value !== null) {
+      const record = getIsOnlyAnObject(value) ? value : {};
+      return Object.keys(record).filter((key) => Boolean(key) && Boolean(record[key])).map((key) => `${key}=${record[key]}`);
+    } else {
+      return [];
+    }
   }
   getQueryString(value) {
     if (!value) return "";
@@ -610,7 +640,7 @@ var AbortableFetch2 = class {
     if (!obj) return headers;
     if (typeof obj !== "object" || Array.isArray(obj)) throw new Error("Not valid headers value!");
     Object.keys(obj).forEach((key) => {
-      headers.append(key, obj[key]);
+      headers.append(key, `${obj[key]}`);
     });
     return headers;
   }
@@ -686,39 +716,64 @@ var AbortableFetch2 = class {
       // isAnywayRunCallback,
       isResponseAsObject
     } = input;
-    if (pathPrefix) this.setPathPrefix(pathPrefix);
-    if (method) this.setMethod(method);
+    if (pathPrefix) this.setPathPrefix(typeof pathPrefix === "string" ? pathPrefix : null);
+    if (method) this.setMethod(typeof method === "string" && isHttpMethod(method) ? method : null);
     if (queryParameters) this.setQueryParameters(this.getQueryArray(queryParameters));
-    if (headers) this.setHeaders(headers);
+    if (headers) this.setHeaders(getIsOnlyAnObject(headers) ? headers : null);
     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 (options) this.setOptions(getIsOnlyAnObject(options) ? options : null);
+    if (callback && typeof callback === "function") {
+      const fn = callback;
+      this.setCallback(function wrappedCallback(response) {
+        return fn.call(this, response);
+      });
+    }
+    if (catchCallback && typeof catchCallback === "function") {
+      const fn = catchCallback;
+      this.setCatchCallback(function wrappedCatchCallback(response) {
+        return fn.call(this, response);
+      });
+    }
+    if (everyPromiseCallback && typeof everyPromiseCallback === "function") {
+      const fn = everyPromiseCallback;
+      this.setEveryPromiseCallback(function wrappedEveryPromiseCallback(response) {
+        return fn.call(this, response);
+      });
+    }
     if (isResponseAsObject !== void 0) this.setIsResponseAsObject(isResponseAsObject);
   }
 };
 var AbortableFetch_default2 = AbortableFetch2;
 
-// src/Classes/RESTAPI/partials/_utils.js
+// src/Classes/RESTAPI/partials/_utils.ts
 function getIsOnlyAnObject(input) {
-  return typeof input === "object" && // "отбивает" примитивы и функции
-  input instanceof Object && // "отбивает" null
-  !Array.isArray(input) && // "отбивает" массивы
-  !(input instanceof Set) && // "отбивает" сеты
-  !(input instanceof Map);
+  return typeof input === "object" && input instanceof Object && !Array.isArray(input) && !(input instanceof Set) && !(input instanceof Map);
 }
-var clone = (input) => {
+function 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]);
+  if (Array.isArray(input)) return input.map((item) => clone(item));
+  const source = getIsOnlyAnObject(input) ? input : {};
+  const data = {};
+  Object.keys(source).forEach((key) => {
+    data[key] = clone(source[key]);
+  });
   return data;
-};
-var omitKeys = (obj = {}, keys = []) => keys.reduce((acc, key) => {
-  const { [key]: omit, ...rest } = acc;
-  return rest;
-}, obj);
-var getResponseClone = async (res) => typeof res?.clone === "function" ? await res.clone() : clone(res);
+}
+function omitKeys(obj, keys = []) {
+  const source = obj ?? {};
+  const keySet = new Set(keys);
+  const result = {};
+  Object.keys(source).forEach((key) => {
+    if (!keySet.has(key)) result[key] = source[key];
+  });
+  return result;
+}
+async function getResponseClone(res) {
+  if (res && typeof res === "object" && "clone" in res && typeof res.clone === "function") {
+    return res.clone();
+  }
+  return clone(res);
+}
 function addCustomMethods(data, prefix) {
   const preparedPrefix = (prefix || "").toString();
   Object.keys(data).forEach((key) => {
@@ -732,7 +787,7 @@ async function getInstanceOfFetchSystem(isGetBody) {
   let credentials = {};
   if (CREDENTIALS_CONTEXT) {
     const cred = await CREDENTIALS_CONTEXT.getCredentials();
-    credentials = CREDENTIALS_CONTEXT.isUseRefreshTokensPropcessing ? await CREDENTIALS_CONTEXT.waitRefresh(cred.isNeedRefresh && !CREDENTIALS_CONTEXT.getIsTokenStartRefresh()).then(
+    credentials = CREDENTIALS_CONTEXT.isUseRefreshTokensPropcessing ? await CREDENTIALS_CONTEXT.waitRefresh(Boolean(cred.isNeedRefresh) && !CREDENTIALS_CONTEXT.getIsTokenStartRefresh()).then(
       async () => CREDENTIALS_CONTEXT.processCredentials(await CREDENTIALS_CONTEXT.getCredentials())
     ) : cred;
   }
@@ -750,52 +805,57 @@ async function getInstanceOfFetchSystem(isGetBody) {
   }
   return (CREDENTIALS_CONTEXT?.isUseRefreshTokensPropcessing ? CREDENTIALS_CONTEXT.waitRefresh() : Promise.resolve()).then(
     async () => new AbortableFetch_default2({
-      //? Метод по умолчанию
+      // ? Метод по умолчанию
       method: "GET",
-      //? Заголовки по умолчанию
+      // ? Заголовки по умолчанию
       headers: {
         ...headersToAbortableFetchInstance,
-        //? (*) Тут обрабатываются кейсы
-        //?   - когда нет this.credentialsProcessing
-        //?     (мы НЕ хотим добавлять токены в принципе, не зашли в верхнюю if-ку)
-        //?   - когда есть this.credentialsProcessing, но нет credentials.token (не авторизованы)
-        //?     (зашли в верхнюю if-ку, попробовали получить/обновить креды)
+        // ? (*) Тут обрабатываются кейсы
+        // ?   - когда нет this.credentialsProcessing
+        // ?     (мы НЕ хотим добавлять токены в принципе, не зашли в верхнюю if-ку)
+        // ?   - когда есть this.credentialsProcessing, но нет credentials.token (не авторизованы)
+        // ?     (зашли в верхнюю if-ку, попробовали получить/обновить креды)
         ...credentials.token ? CREDENTIALS_CONTEXT?.getHeadersForAuthorize?.(credentials.token) || {} : {}
       },
       queryParameters: await API_CONTEXT.processQueryParams(queryParamsToAbortableFetchInstance),
-      //? Опции по умолчанию
+      // ? Опции по умолчанию
       options: {
         mode: "cors",
         redirect: "follow",
         ...optionsToAbortableFetchInstance
       },
-      //? Каждый запрос (каждый запрос мультизапроса), сделаный методом request этого экземпляра выполнит этот колбек
+      // ? Каждый запрос (каждый запрос мультизапроса), сделаный методом request этого экземпляра выполнит этот колбек
       everyPromiseCallback: async function everyPromiseCallback(response) {
         const ABORTABLE_FETCH_INSTANCE = this;
         if (!response.status) {
-          const request = ABORTABLE_FETCH_INSTANCE.requestInput.find((item) => item?.path === response?.request?.path);
-          const isUseErrorToast = request?.mesageOptions?.isUseErrorToast;
+          const reqInput = ABORTABLE_FETCH_INSTANCE.requestInput;
+          const responseRequest = getIsOnlyAnObject(response.request) ? response.request : {};
+          const request = Array.isArray(reqInput) ? reqInput.find((item) => getIsOnlyAnObject(item) && item.path === responseRequest.path) : void 0;
+          const mesageOptions = getIsOnlyAnObject(request) && getIsOnlyAnObject(request.mesageOptions) ? request.mesageOptions : void 0;
+          const isUseErrorToast = mesageOptions?.isUseErrorToast;
           if (isUseErrorToast) {
-            API_CONTEXT.sendMessage?.(API_CONTEXT.NO_INET, request.mesageOptions, response);
+            API_CONTEXT.sendMessage?.(API_CONTEXT.NO_INET, mesageOptions, response);
           }
         }
-        return API_CONTEXT.REJECT_CODES.includes(response.status) || CREDENTIALS_CONTEXT?.isUseRefreshTokensPropcessing && CREDENTIALS_CONTEXT?.CODES_USING_THE_REFRESH_ATTEMPT?.includes?.(response.status) ? Promise.reject(new Error(`status:${response.status}`)) : Promise.resolve(!isGetBody ? response : await API_CONTEXT.getResponseBody(response));
+        return API_CONTEXT.REJECT_CODES.includes(Number(response.status)) || CREDENTIALS_CONTEXT?.isUseRefreshTokensPropcessing && Boolean(CREDENTIALS_CONTEXT?.CODES_USING_THE_REFRESH_ATTEMPT?.includes(Number(response.status))) ? Promise.reject(new Error(`status:${Number(response.status)}`)) : Promise.resolve(!isGetBody ? response : await API_CONTEXT.getResponseBody(response));
       },
-      //? Если хоть один запрос из пачки будет зареджекчен, зареджектится вся пачка.
-      //? В этом случае будет выполнен этот колбэк
+      // ? Если хоть один запрос из пачки будет зареджекчен, зареджектится вся пачка.
+      // ? В этом случае будет выполнен этот колбэк
       catchCallback: async function catchCallback(res) {
         const ABORTABLE_FETCH_INSTANCE = this;
-        const code = Number(res.message.split(":")[1]);
-        if (CREDENTIALS_CONTEXT?.CODES_USING_THE_REFRESH_ATTEMPT?.includes?.(code)) {
-          const isDoRefresh = !CREDENTIALS_CONTEXT?.getIsTokenStartRefresh?.();
-          return CREDENTIALS_CONTEXT?.waitRefresh(isDoRefresh).then(async () => {
-            const newCredentials = await CREDENTIALS_CONTEXT?.processCredentials({
-              ...await CREDENTIALS_CONTEXT?.getCredentials(true),
+        if (!CREDENTIALS_CONTEXT) return Promise.reject(res);
+        const code = Number(res instanceof Error ? res.message.split(":")[1] : "");
+        if (CREDENTIALS_CONTEXT.CODES_USING_THE_REFRESH_ATTEMPT?.includes(code)) {
+          const isDoRefresh = !CREDENTIALS_CONTEXT.getIsTokenStartRefresh();
+          return CREDENTIALS_CONTEXT.waitRefresh(isDoRefresh).then(async () => {
+            const newCredentials = await CREDENTIALS_CONTEXT.processCredentials({
+              ...await CREDENTIALS_CONTEXT.getCredentials(true),
               isCatchCallbackProcess: isDoRefresh
             });
+            const currentHeaders = ABORTABLE_FETCH_INSTANCE.getHeaders();
             ABORTABLE_FETCH_INSTANCE.setHeaders({
-              ...ABORTABLE_FETCH_INSTANCE.getHeaders(),
-              ...newCredentials?.token ? { Authorization: `Bearer ${newCredentials?.token}` } : {}
+              ...getIsOnlyAnObject(currentHeaders) ? currentHeaders : {},
+              ...newCredentials.token ? { Authorization: `Bearer ${newCredentials.token}` } : {}
             });
             if (newCredentials.token) return ABORTABLE_FETCH_INSTANCE.repeatRequest();
             return Promise.reject(res);
@@ -807,13 +867,23 @@ async function getInstanceOfFetchSystem(isGetBody) {
   );
 }
 
-// src/Classes/RESTAPI/partials/Utils.js
+// src/Classes/RESTAPI/partials/Utils.ts
 var Utils = class {
-  //! Могут содержаться НЕасинхронные методы!
-  //? Ф-я normalizeQueryParams является нормализатором сложных квери
-  //? Например: &key1=&&&===&&&key2====&&&&&&&&key3=....
-  //? Для корректной работы на вход нужно подавать НЕ кодированные значения
-  //? По умолчанию выходные значения квери-параметров НЕ кодируются
+  // ! Могут содержаться НЕасинхронные методы!
+  /**
+   * Нормализатор сложных query-параметров.
+   *
+   * Например: `&key1=&&&===&&&key2====&&&&&&&&key3=...`. Для корректной работы на вход нужно подавать
+   * НЕ кодированные значения. По умолчанию выходные значения query-параметров НЕ кодируются.
+   *
+   * @param queryParams - query в виде строки, массива или объекта.
+   * @param settings    - формат вывода (`array` | `string` | `object`) и флаг кодирования.
+   * @returns Нормализованные query-параметры в выбранном формате.
+   */
+  // ? Ф-я normalizeQueryParams является нормализатором сложных квери
+  // ? Например: &key1=&&&===&&&key2====&&&&&&&&key3=....
+  // ? Для корректной работы на вход нужно подавать НЕ кодированные значения
+  // ? По умолчанию выходные значения квери-параметров НЕ кодируются
   normalizeQueryParams(queryParams, settings) {
     if (settings && !getIsOnlyAnObject(settings)) {
       throw new Error("Bad settings [class Utils, normalizeQueryParams]");
@@ -832,9 +902,13 @@ var Utils = class {
           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 (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 [];
+      } else if (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);
@@ -851,7 +925,9 @@ var Utils = class {
         if (index !== -1 && index !== 0) {
           const key = str.slice(0, index);
           acc.result.push(`${key}=${encodeURIComponent(str.slice(index + 1))}`);
-        } else acc.toJoin = str;
+        } else {
+          acc.toJoin = str;
+        }
         if (idx === initialStructure.length - 1 && typeof acc.toJoin === "string") processToJoin(acc.toJoin);
         return acc;
       },
@@ -859,7 +935,7 @@ var Utils = class {
     ).result;
     const outputStructure = normalizedStructure.map((item) => {
       const [key, value] = item.split("=");
-      return [key, !isEncode ? decodeURIComponent(value) : value];
+      return [key, !isEncode ? decodeURIComponent(value ?? "") : value ?? ""];
     });
     switch (outputAs) {
       case "string":
@@ -873,16 +949,25 @@ var Utils = class {
 };
 var Utils_default = Utils;
 
-// src/Classes/RESTAPI/partials/ApiUtils.js
+// src/Classes/RESTAPI/partials/ApiUtils.ts
 var ApiUtils = class extends Utils_default {
+  /** Корневой путь API (раскладывается в ApiBase из constants.API_PATH). */
+  API_PATH;
   constructor(settings) {
     super();
     const { utils } = settings || {};
     if (getIsOnlyAnObject(utils)) addCustomMethods.call(this, utils);
   }
-  //? Планируется, что метод будет использоваться неизменно, однако технически его можно перегрузить на экземпляре
-  //? Метод не планировался как асинхронный,
-  //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+  /**
+   * Разбирает единый объект параметров запроса на части в зависимости от варианта использования.
+   *
+   * @param apiParams - объединённые параметры запроса.
+   * @param variant   - `'doRequestMapping'` для мультизапроса либо `undefined` для одиночного.
+   * @returns Для `doRequestMapping` — объект параметров; иначе кортеж `[параметры, настройки]`.
+   */
+  // ? Планируется, что метод будет использоваться неизменно, однако технически его можно перегрузить на экземпляре
+  // ? Метод не планировался как асинхронный,
+  // ? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
   async splitProperties(apiParams, variant) {
     const {
       isResponseAsObject,
@@ -941,79 +1026,224 @@ var ApiUtils = class extends Utils_default {
         ];
     }
   }
-  //! Обработчик пропы api из объекта описания запроса
-  //? Планируется, что метод будет перегружаться на экземпляре,
-  //? т.к. на разных проектах могут быть разные интерпретации пропы api
-  //? Метод не планировался как асинхронный,
-  //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+  /**
+   * Обработчик пропы `api` из объекта описания запроса — возвращает корневой путь API.
+   *
+   * @returns Корневой путь (по умолчанию — API_PATH).
+   */
+  // ! Обработчик пропы api из объекта описания запроса
+  // ? Планируется, что метод будет перегружаться на экземпляре,
+  // ? т.к. на разных проектах могут быть разные интерпретации пропы api
+  // ? Метод не планировался как асинхронный,
+  // ? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
   async getRootPath() {
     return this.API_PATH;
   }
-  //? Планируется, что метод будет использоваться неизменно, однако технически его можно перегрузить на экземпляре
-  //? Метод планировался как асинхронный
+  /**
+   * Извлекает тело ответа в нужном виде (json/blob/text/arrayBuffer/formData) либо по content-type.
+   *
+   * @param response  - объект Response (иначе значение возвращается как есть).
+   * @param getBodyAs - желаемый способ извлечения тела.
+   * @returns Промис с телом ответа (или исходным значением / null при ошибке).
+   */
+  // ? Планируется, что метод будет использоваться неизменно, однако технически его можно перегрузить на экземпляре
+  // ? Метод планировался как асинхронный
   async getResponseBody(response, getBodyAs) {
     if (!(response instanceof Response)) return response;
     const contentType = response.headers.get("content-type");
     if (!contentType) return "";
-    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;
-    })();
+    const bodyReaders = {
+      json: (r) => r.json(),
+      blob: (r) => r.blob(),
+      text: (r) => r.text(),
+      arrayBuffer: (r) => r.arrayBuffer(),
+      formData: (r) => r.formData()
+    };
+    const isBodyKey = (key) => key in bodyReaders;
+    const reader = typeof getBodyAs === "string" && isBodyKey(getBodyAs) ? bodyReaders[getBodyAs] : contentType.includes("text/csv") ? bodyReaders.blob : contentType.includes("json") ? bodyReaders.json : bodyReaders.text;
     try {
-      return await executor.call(response);
+      return await reader(response);
     } catch {
       console.log("Failed to extract the body");
       return null;
     }
   }
-  //! Обработчик структуры для ошибки (не рендер месседжа, а имеено формирование ошибки),
-  //? Планируется, что метод будет перегружаться на экземпляре,
-  //? т.к. на разных проектах могут быть разные структуры тела ответа для ошибки
-  //? Метод не планировался как асинхронный,
-  //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
-  //? res - уже тело ответа
+  /**
+   * Формирует структуру ошибки из тела ответа (точка расширения под формат бэкенда).
+   *
+   * @param res - уже извлечённое тело ответа.
+   * @returns Структура сообщения об ошибке.
+   */
+  // ! Обработчик структуры для ошибки (не рендер месседжа, а имеено формирование ошибки),
+  // ? Планируется, что метод будет перегружаться на экземпляре,
+  // ? т.к. на разных проектах могут быть разные структуры тела ответа для ошибки
+  // ? Метод не планировался как асинхронный,
+  // ? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+  // ? res - уже тело ответа
   async getErrorMessage(res) {
     return res;
   }
-  //? Планируется, что метод будет использоваться неизменно, однако технически его можно перегрузить на экземпляре
-  //? Метод планировался как асинхронный
+  /**
+   * Проверяет код ответа и (если задан sendMessage) информирует пользователя об успехе/ошибке.
+   *
+   * @param res      - объект Response (или совместимый с полем `ok`).
+   * @param settings - сообщения и настройки тостов для данного запроса.
+   * @returns Исходный `res` (метод не меняет ответ, только сигналит сообщением).
+   */
+  // ? Планируется, что метод будет использоваться неизменно, однако технически его можно перегрузить на экземпляре
+  // ? Метод планировался как асинхронный
   async checkResponseCode(res, settings) {
-    if (typeof this.sendMessage !== "function") return res;
+    const send = this.sendMessage;
+    if (typeof send !== "function") return res;
     const { successMess, errorMess } = settings || {};
-    const message = res.ok ? successMess || this.DEFAULT_SUCCESS_MESSAGE : errorMess || await this.getErrorMessage(await this.getResponseBody(await getResponseClone(res)));
+    const isOk = getIsOnlyAnObject(res) ? Boolean(res.ok) : false;
+    const message = isOk ? successMess || this.DEFAULT_SUCCESS_MESSAGE : errorMess || await this.getErrorMessage(await this.getResponseBody(await getResponseClone(res)));
     try {
-      this.sendMessage(message, settings, await getResponseClone(res));
-    } catch (_error) {
+      send(message, settings, await getResponseClone(res));
+    } catch {
     }
     return res;
   }
-  //? Суть метода:
-  //? передать из вне структуры, которые будут использоваться для КАЖДОГО запроса сделанного экземпляром RESTAPI
-  //! Данные затрут прочие настройки КРОМЕ данных по логике авторизации
-  //? Планируется, что метод будет перегружаться на экземпляре
-  //? Метод не планировался как асинхронный,
-  //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+  /**
+   * Структуры, которые будут использоваться для КАЖДОГО запроса, сделанного экземпляром RESTAPI.
+   *
+   * @returns Объект `{ headers, queryParameters, options }` (по умолчанию пустой).
+   */
+  // ? Суть метода:
+  // ? передать из вне структуры, которые будут использоваться для КАЖДОГО запроса сделанного экземпляром RESTAPI
+  // ! Данные затрут прочие настройки КРОМЕ данных по логике авторизации
+  // ? Планируется, что метод будет перегружаться на экземпляре
+  // ? Метод не планировался как асинхронный,
+  // ? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
   async addAsCommon() {
     return {};
   }
-  //! Обработчик квери-параметров для общего процессинга,
-  //! Например для кодирования decodeURIComponent или/и приведения в формат массива
-  //? Планируется, что метод будет перегружаться на экземпляре,
-  //? т.к. на разных проектах могут быть разные договоренности по форматам
-  //? Метод не планировался как асинхронный,
-  //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+  /**
+   * Общий обработчик query-параметров (точка расширения, напр. кодирование/приведение к массиву).
+   *
+   * @param queryParams - входные query-параметры.
+   * @returns Обработанные query-параметры (по умолчанию — без изменений).
+   */
+  // ! Обработчик квери-параметров для общего процессинга,
+  // ! Например для кодирования decodeURIComponent или/и приведения в формат массива
+  // ? Планируется, что метод будет перегружаться на экземпляре,
+  // ? т.к. на разных проектах могут быть разные договоренности по форматам
+  // ? Метод не планировался как асинхронный,
+  // ? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
   async processQueryParams(queryParams) {
     return queryParams;
   }
 };
 var ApiUtils_default = ApiUtils;
 
-// src/Classes/RESTAPI/partials/ApiRequestCreators.js
+// src/Classes/RESTAPI/partials/sse.ts
+function parseSSEEvent(block) {
+  if (typeof block !== "string") return null;
+  const event = { event: "message", data: "", id: void 0, retry: void 0 };
+  const dataLines = [];
+  let hasField = false;
+  block.split("\n").forEach((line) => {
+    if (line === "" || line[0] === ":") return;
+    const colonIdx = line.indexOf(":");
+    const field = colonIdx === -1 ? line : line.slice(0, colonIdx);
+    let value = colonIdx === -1 ? "" : line.slice(colonIdx + 1);
+    if (value[0] === " ") value = value.slice(1);
+    switch (field) {
+      case "event":
+        event.event = value;
+        hasField = true;
+        break;
+      case "data":
+        dataLines.push(value);
+        hasField = true;
+        break;
+      case "id":
+        event.id = value;
+        hasField = true;
+        break;
+      case "retry":
+        if (/^\d+$/.test(value)) {
+          event.retry = Number(value);
+          hasField = true;
+        }
+        break;
+      default:
+        break;
+    }
+  });
+  if (!hasField) return null;
+  event.data = dataLines.join("\n");
+  return event;
+}
+function safeCall(fn, ...args) {
+  if (typeof fn !== "function") return;
+  try {
+    fn(...args);
+  } catch {
+  }
+}
+async function readSSE(response, { onEvent, onChunk, handlers, parseJson } = {}) {
+  const events = [];
+  const stream = response.body;
+  if (!stream) return events;
+  const reader = stream.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let pendingCR = "";
+  const normalize = (chunk) => chunk.replace(/\r\n|\r/g, "\n");
+  const flush = (rawBlock) => {
+    const event = parseSSEEvent(rawBlock);
+    if (!event) return;
+    if (parseJson && typeof event.data === "string" && event.data !== "") {
+      try {
+        event.data = JSON.parse(event.data);
+      } catch {
+      }
+    }
+    events.push(event);
+    safeCall(onEvent, event);
+    safeCall(onChunk, event.data, event);
+    if (handlers) safeCall(handlers[event.event], event.data, event);
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      let chunk = pendingCR + decoder.decode(value, { stream: true });
+      pendingCR = "";
+      if (chunk.endsWith("\r")) {
+        pendingCR = "\r";
+        chunk = chunk.slice(0, -1);
+      }
+      buffer += normalize(chunk);
+      let sepIdx;
+      while ((sepIdx = buffer.indexOf("\n\n")) !== -1) {
+        const rawBlock = buffer.slice(0, sepIdx);
+        buffer = buffer.slice(sepIdx + 2);
+        flush(rawBlock);
+      }
+    }
+    buffer += normalize(pendingCR + decoder.decode());
+    buffer = buffer.replace(/\n+$/g, "");
+    if (buffer !== "") flush(buffer);
+  } catch (error) {
+    const name = error && typeof error === "object" && "name" in error ? error.name : void 0;
+    if (name !== "AbortError") throw error;
+  } finally {
+    try {
+      reader.releaseLock?.();
+    } catch {
+    }
+  }
+  return events;
+}
+
+// src/Classes/RESTAPI/partials/ApiRequestCreators.ts
+function isStreamResponse(value) {
+  if (!getIsOnlyAnObject(value) || !value.ok) return false;
+  const body = value.body;
+  return typeof body === "object" && body !== null && "getReader" in body && typeof body.getReader === "function";
+}
 var PREFIX_OF_CLASS_UTILS = "createRequest_";
 var ApiRequestCreators = class extends ApiUtils_default {
   constructor(settings) {
@@ -1021,8 +1251,14 @@ var ApiRequestCreators = class extends ApiUtils_default {
     const { requestsCreators } = settings || {};
     if (getIsOnlyAnObject(requestsCreators)) addCustomMethods.call(this, requestsCreators, PREFIX_OF_CLASS_UTILS);
   }
-  //? При типе toJson пользовательский callback на вход получит тело ответа реализованное методом Response.json()
-  //? независимо от насторойки isGetBody
+  /**
+   * Крейтер типа `toJson`: пользовательский callback получит тело ответа (Response.json()).
+   *
+   * @param props   - объект описания запроса.
+   * @param variant - вариант обработки splitProperties.
+   */
+  // ? При типе toJson пользовательский callback на вход получит тело ответа реализованное методом Response.json()
+  // ? независимо от насторойки isGetBody
   async createRequest_toJson(props, variant) {
     const safelyProps = omitKeys(props, ["getBodyAs"]);
     return this.splitProperties(
@@ -1031,15 +1267,21 @@ var ApiRequestCreators = class extends ApiUtils_default {
         isGetBody: false,
         callback: async (res) => {
           const output = await this.getResponseBody(res, "json");
-          return await (safelyProps.callback?.(output) ?? output);
+          return await (props.callback?.(output) ?? output);
         }
       },
       variant
     );
   }
-  //? При типе toJsonAdvanced пользовательский callback на вход получит структуру { response, result },
-  //? где response - объект Response, result - тело ответа реализованное методом Response.json()
-  //? независимо от насторойки isGetBody
+  /**
+   * Крейтер типа `toJsonAdvanced`: callback получит структуру `{ response, result }`.
+   *
+   * @param props   - объект описания запроса.
+   * @param variant - вариант обработки splitProperties.
+   */
+  // ? При типе toJsonAdvanced пользовательский callback на вход получит структуру { response, result },
+  // ? где response - объект Response, result - тело ответа реализованное методом Response.json()
+  // ? независимо от насторойки isGetBody
   async createRequest_toJsonAdvanced(props, variant) {
     const safelyProps = omitKeys(props, ["getBodyAs"]);
     return this.splitProperties(
@@ -1051,14 +1293,20 @@ var ApiRequestCreators = class extends ApiUtils_default {
             response: res,
             result: await this.getResponseBody(await getResponseClone(res), "json")
           };
-          return await (safelyProps.callback?.(output) ?? output);
+          return await (props.callback?.(output) ?? output);
         }
       },
       variant
     );
   }
-  //? При типе blob пользовательский callback на вход получит тело ответа реализованное методом Response.blob(),
-  //? независимо от насторойки isGetBody
+  /**
+   * Крейтер типа `blob`: callback получит тело ответа (Response.blob()).
+   *
+   * @param props   - объект описания запроса.
+   * @param variant - вариант обработки splitProperties.
+   */
+  // ? При типе blob пользовательский callback на вход получит тело ответа реализованное методом Response.blob(),
+  // ? независимо от насторойки isGetBody
   async createRequest_blob(props, variant) {
     const safelyProps = omitKeys(props, ["getBodyAs"]);
     return this.splitProperties(
@@ -1067,14 +1315,67 @@ var ApiRequestCreators = class extends ApiUtils_default {
         isGetBody: false,
         callback: async (res) => {
           const output = await this.getResponseBody(await getResponseClone(res), "blob");
-          return await (safelyProps.callback?.(output) ?? output);
+          return await (props.callback?.(output) ?? output);
+        }
+      },
+      variant
+    );
+  }
+  /**
+   * Крейтер типа `sse`: обрабатывает ответ как поток Server-Sent Events (text/event-stream).
+   *
+   * Дополнительные пропы объекта описания запроса: `onEvent`, `onChunk`, `handlers`, `parseJson`.
+   * По умолчанию добавляется заголовок `Accept: text/event-stream`. Метод doRequest резолвится
+   * массивом всех событий ПОСЛЕ закрытия потока; отмена — методом `.abort()` возвращённого промиса.
+   *
+   * @param props   - объект описания запроса (плюс onEvent/onChunk/handlers/parseJson).
+   * @param variant - вариант обработки splitProperties.
+   */
+  // ? При типе sse запрос обрабатывается как поток Server-Sent Events (text/event-stream).
+  // ? Дополнительные пропы объекта описания запроса:
+  // ?   - onEvent(event) — вызывается на каждое распарсенное событие { event, data, id, retry };
+  // ?   - onChunk(data, event) — вызывается на полезную нагрузку (поле data) каждого события;
+  // ?   - handlers — карта { имяСобытия: cb } для типизированной обработки по полю event
+  // ?     (например { delta, status, done }); cb получает (data, event);
+  // ?   - parseJson — если true, поле data каждого события прогоняется через JSON.parse.
+  // ? По умолчанию добавляется заголовок Accept: text/event-stream (его можно переопределить через headers).
+  // ? Пользовательский callback (если передан) на вход получит итоговый массив всех событий.
+  // ? Метод doRequest резолвится массивом всех событий ПОСЛЕ закрытия потока;
+  // ? отмена потока выполняется методом .abort() возвращённого промиса (через встроенный AbortController).
+  async createRequest_sse(props, variant) {
+    const safelyProps = omitKeys(props, ["getBodyAs", "onChunk", "onEvent", "handlers", "parseJson"]);
+    const { onChunk, onEvent, handlers, parseJson } = props;
+    const sseOptions = {
+      onChunk: typeof onChunk === "function" ? (data, event) => onChunk(data, event) : void 0,
+      onEvent: typeof onEvent === "function" ? (event) => onEvent(event) : void 0,
+      parseJson: Boolean(parseJson),
+      handlers: getIsOnlyAnObject(handlers) ? Object.keys(handlers).reduce((acc, key) => {
+        const fn = handlers[key];
+        acc[key] = typeof fn === "function" ? (data, event) => fn(data, event) : void 0;
+        return acc;
+      }, {}) : void 0
+    };
+    return this.splitProperties(
+      {
+        ...safelyProps,
+        headers: { Accept: "text/event-stream", ...getIsOnlyAnObject(safelyProps.headers) ? safelyProps.headers : {} },
+        isGetBody: false,
+        callback: async (res) => {
+          const output = isStreamResponse(res) ? await readSSE(res, sseOptions) : res;
+          return await (props.callback?.(output) ?? output);
         }
       },
       variant
     );
   }
-  //? При типе testBadResponse пользовательский callback на вход получит объект Response в 401-м статусе
-  //? независимо независимо вообще ни от чего
+  /**
+   * Крейтер типа `testBadResponse`: callback получит синтетический Response со статусом 401.
+   *
+   * @param props   - объект описания запроса.
+   * @param variant - вариант обработки splitProperties.
+   */
+  // ? При типе testBadResponse пользовательский callback на вход получит объект Response в 401-м статусе
+  // ? независимо независимо вообще ни от чего
   async createRequest_testBadResponse(props, variant) {
     return this.splitProperties(
       {
@@ -1094,17 +1395,33 @@ var ApiRequestCreators = class extends ApiUtils_default {
       variant
     );
   }
-  //? По умолчанию пользовательский callback на вход получит
-  //?   - либо объект Response
-  //?   - либо тело ответа (в случае isGetBody: 'first') полученное методом getResponseBody (смотри класс ApiUtils)
+  /**
+   * Крейтер по умолчанию: callback получит объект Response (или тело ответа при isGetBody: 'first').
+   *
+   * @param props   - объект описания запроса.
+   * @param variant - вариант обработки splitProperties.
+   */
+  // ? По умолчанию пользовательский callback на вход получит
+  // ?   - либо объект Response
+  // ?   - либо тело ответа (в случае isGetBody: 'first') полученное методом getResponseBody (смотри класс ApiUtils)
   async createRequest_default(props, variant) {
     return this.splitProperties(props, variant);
   }
 };
 var ApiRequestCreators_default = ApiRequestCreators;
 
-// src/Classes/RESTAPI/partials/ApiBase.js
+// src/Classes/RESTAPI/partials/ApiBase.ts
 var ApiBase = class extends ApiRequestCreators_default {
+  /** Текст ошибки невалидных данных запроса. */
+  BAD_REQUEST_DATA_TEXT;
+  /** Текст сообщения об успехе по умолчанию. */
+  DEFAULT_SUCCESS_MESSAGE;
+  /** Текст сообщения об ошибке по умолчанию. */
+  DEFAULT_ERROR_MESSAGE;
+  /** Текст сообщения об отсутствии сети. */
+  NO_INET;
+  /** Коды ответа, по которым запрос считается отклонённым. */
+  REJECT_CODES;
   constructor(settings) {
     super(settings);
     const {
@@ -1133,49 +1450,76 @@ var ApiBase = class extends ApiRequestCreators_default {
 };
 var ApiBase_default = ApiBase;
 
-// src/Classes/RESTAPI/partials/CredentialsProcessing.js
+// src/Classes/RESTAPI/partials/CredentialsProcessing.ts
 function decodeJWT(token) {
   try {
-    const payload = token.split(".")[1];
-    return JSON.parse(atob(payload));
-  } catch (e) {
+    const payload = token.split(".")[1] ?? "";
+    const decoded = JSON.parse(atob(payload));
+    return getIsOnlyAnObject(decoded) ? decoded : null;
+  } catch {
     return null;
   }
 }
 var CredentialsProcessing = class {
+  /** Включён ли флоу рефреша токенов. */
+  isUseRefreshTokensPropcessing = false;
+  /** Учётные данные по умолчанию (пустые). */
+  DEFAULT_CREDENTIALS = {};
+  /** Внешний метод получения учётных данных. */
+  getCredentialsByOuter;
+  /** Внешний метод формирования заголовков авторизации по токену. */
+  getHeadersForAuthorize;
+  /** Необязательный преобразователь учётных данных после getCredentials. */
+  importCredentials;
+  /** Необязательный метод сохранения учётных данных (обязателен для флоу рефреша). */
+  saveCredentials;
+  /** Внешний метод рефреша учётных данных. */
+  refreshCredentialsByOuter;
+  /** Полный путь до эндпоинта рефреша токена. */
+  REFRESH_TOKEN_PATH;
+  /** Коды ответа, по которым триггерится попытка рефреша. */
+  CODES_USING_THE_REFRESH_ATTEMPT;
+  /** Ключ флага «рефреш начат» в localStorage. */
+  REFRESH_TOKEN_FLAG = "refreshTokenFlag";
+  /** Интервал опроса флага обновления токена, мс. */
+  INTERVAL_FOR_CHECKING_TOKEN_UPDATE = 50;
+  /** Колбэк, вызываемый после неудачного рефреша. */
+  callbackAfterRejectRefresh;
+  /** Доступ к верхнему контексту RESTAPI (навешивается из конструктора RESTAPI). */
+  getRESTAPIContext;
   constructor(settings) {
     const { credentialsProcessing } = settings;
     const {
-      //? Для корректной работы установки токенов в запросы от API
-      //? нужно передавать методы getCredentials и getHeadersForAuthorize
+      // ? Для корректной работы установки токенов в запросы от API
+      // ? нужно передавать методы getCredentials и getHeadersForAuthorize
       getCredentials,
       getHeadersForAuthorize,
-      //? На вход получит токен, должна вернуть объект для коструктора Headers
-      //? Так же опционально можно передавать
+      // ? На вход получит токен, должна вернуть объект для коструктора Headers
+      // ? Так же опционально можно передавать
       importCredentials,
-      //? если он передается, то он будет применяться к выводу от вызова getCredentials
+      // ? если он передается, то он будет применяться к выводу от вызова getCredentials
       saveCredentials,
-      //? можно будет найти в объекте credentialsProcessing, чтобы использовать кастомными методами
-      //! Либо вызов getCredentials, либо цепочка вызовов importCredentials(getCredentials())
-      //! должна возвращать требуемую классом структуру
-      //! Класс требует структуры
-      //!   - { token }, если флоу рефреш токена НЕ используется
-      //!   - { token, refreshToken, expires }, если используется флоу рефреш токена
+      // ? можно будет найти в объекте credentialsProcessing, чтобы использовать кастомными методами
+      // ! Либо вызов getCredentials, либо цепочка вызовов importCredentials(getCredentials())
+      // ! должна возвращать требуемую классом структуру
+      // ! Класс требует структуры
+      // !   - { token }, если флоу рефреш токена НЕ используется
+      // !   - { token, refreshToken, expires }, если используется флоу рефреш токена
       // *********
-      //? Подключает флоу рефреша токенов
+      // ? Подключает флоу рефреша токенов
       isUseRefreshTokensPropcessing = false,
-      //! Для корректной работы флоу рефреша токенов передача метода saveCredentials становится ОБЯЗАТЕЛЬНОЙ
-      //? Так же для корректной работы флоу рефреша токенов нужно
-      //?   - либо
+      // ! Для корректной работы флоу рефреша токенов передача метода saveCredentials становится ОБЯЗАТЕЛЬНОЙ
+      // ? Так же для корректной работы флоу рефреша токенов нужно
+      // ?   - либо
       refreshCredentials,
-      //! метод должен возвращать такую же структуру как и метод getCredentials,
-      //? на вход получит текущие креды, к выходу будет применен importCredentials, если этот метод передавался
-      //?   - либо
+      // ! метод должен возвращать такую же структуру как и метод getCredentials,
+      // ? на вход получит текущие креды, к выходу будет применен importCredentials, если этот метод передавался
+      // ?   - либо
       REFRESH_TOKEN_PATH,
-      //! REFRESH_TOKEN_PATH передается ПОЛНОСТЬЮ (глобальная адресация)!
+      // ! REFRESH_TOKEN_PATH передается ПОЛНОСТЬЮ (глобальная адресация)!
       CODES_USING_THE_REFRESH_ATTEMPT,
-      //? указывает по каким кодам ответа триггериться рефреш, массив чисел
-      //? Опционально
+      // ? указывает по каким кодам ответа триггериться рефреш, массив чисел
+      // ? Опционально
       REFRESH_TOKEN_FLAG = "refreshTokenFlag",
       INTERVAL_FOR_CHECKING_TOKEN_UPDATE = 50,
       // ms
@@ -1183,40 +1527,44 @@ var CredentialsProcessing = class {
     } = credentialsProcessing || {};
     if (typeof getCredentials !== "function") throw new Error("No getCredentials method [CredentialsProcessing]");
     if (typeof getHeadersForAuthorize !== "function") {
-      throw new Error("No getHeadersForAuthorize method [CredentialsProcessing]");
+      throw new TypeError("No getHeadersForAuthorize method [CredentialsProcessing]");
     }
     if (importCredentials && typeof importCredentials !== "function") {
       throw new Error("Bad importCredentials method [CredentialsProcessing]");
     }
-    this.isUseRefreshTokensPropcessing = isUseRefreshTokensPropcessing;
+    this.isUseRefreshTokensPropcessing = Boolean(isUseRefreshTokensPropcessing);
     this.DEFAULT_CREDENTIALS = {};
-    this.getCredentialsByOuter = getCredentials;
-    this.getHeadersForAuthorize = getHeadersForAuthorize;
-    this.importCredentials = importCredentials;
+    this.getCredentialsByOuter = () => getCredentials();
+    this.getHeadersForAuthorize = (token) => {
+      const result = getHeadersForAuthorize(token);
+      return getIsOnlyAnObject(result) ? result : {};
+    };
+    if (typeof importCredentials === "function") this.importCredentials = (cred) => importCredentials(cred);
     if (saveCredentials || isUseRefreshTokensPropcessing) {
       if (typeof saveCredentials !== "function") throw new Error("No saveCredentials method [CredentialsProcessing]");
-      else this.saveCredentials = saveCredentials;
+      else this.saveCredentials = (cred) => saveCredentials(cred);
     }
     if (isUseRefreshTokensPropcessing) {
-      if (typeof refreshCredentials === "function") this.refreshCredentialsByOuter = refreshCredentials;
-      else {
+      if (typeof refreshCredentials === "function") {
+        this.refreshCredentialsByOuter = (cred) => refreshCredentials(cred);
+      } else {
         if (typeof this.refreshCredentialsByOuter === "function" && typeof REFRESH_TOKEN_PATH !== "string") {
-          throw new Error("No REFRESH_TOKEN_PATH [CredentialsProcessing]");
+          throw new TypeError("No REFRESH_TOKEN_PATH [CredentialsProcessing]");
         }
-        this.REFRESH_TOKEN_PATH = REFRESH_TOKEN_PATH;
+        this.REFRESH_TOKEN_PATH = typeof REFRESH_TOKEN_PATH === "string" ? REFRESH_TOKEN_PATH : void 0;
       }
       if (!Array.isArray(CODES_USING_THE_REFRESH_ATTEMPT)) {
-        throw new Error("No CODES_USING_THE_REFRESH_ATTEMPT [CredentialsProcessing]");
+        throw new TypeError("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]");
+        throw new TypeError("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]");
+        throw new TypeError("Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE [CredentialsProcessing]");
       }
       if (callbackAfterRejectRefresh && typeof callbackAfterRejectRefresh !== "function") {
         throw new Error("Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE [CredentialsProcessing]");
@@ -1224,23 +1572,33 @@ var CredentialsProcessing = class {
       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;
+      if (typeof callbackAfterRejectRefresh === "function") this.callbackAfterRejectRefresh = () => callbackAfterRejectRefresh();
     }
   }
+  /** Возвращает значение флага «рефреш начат» из localStorage. */
   getIsTokenStartRefresh() {
     return localStorage.getItem(this.REFRESH_TOKEN_FLAG);
   }
+  /** Выставляет флаг «рефреш начат» в localStorage. */
   setIsTokenStartRefresh() {
-    localStorage.setItem(this.REFRESH_TOKEN_FLAG, true);
+    localStorage.setItem(this.REFRESH_TOKEN_FLAG, String(true));
   }
+  /** Снимает флаг «рефреш начат» из localStorage. */
   removeIsTokenStartRefresh() {
     localStorage.removeItem(this.REFRESH_TOKEN_FLAG);
   }
+  /**
+   * Возвращает текущие учётные данные (с учётом importCredentials и проверки истечения JWT).
+   *
+   * @param isCatchCallbackProcess - флаг процесса обработки ошибки (отключает проверку истечения).
+   * @param callback               - необязательный колбэк, получающий итоговые учётные данные.
+   * @returns Промис с учётными данными.
+   */
   async getCredentials(isCatchCallbackProcess, callback) {
     let credentials = await this.getCredentialsByOuter();
     if (typeof this.importCredentials === "function") credentials = await this.importCredentials(credentials);
-    if (!getIsOnlyAnObject(credentials)) credentials = {};
-    const token = credentials.token || null;
+    const credObj = getIsOnlyAnObject(credentials) ? credentials : {};
+    const token = credObj.token || null;
     if (token && !isCatchCallbackProcess) {
       let decoded;
       try {
@@ -1249,11 +1607,18 @@ var CredentialsProcessing = class {
         decoded = null;
       }
       const currentTime = Date.now() / 1e3;
-      if (decoded !== null && Number(decoded.exp) < currentTime) credentials = { ...credentials, isNeedRefresh: true };
+      if (decoded !== null && Number(decoded.exp) < currentTime) credObj.isNeedRefresh = true;
     }
-    if (callback) await callback({ ...credentials, isCatchCallbackProcess });
-    return { ...credentials, isCatchCallbackProcess };
+    if (callback) await callback({ ...credObj, isCatchCallbackProcess });
+    return { ...credObj, isCatchCallbackProcess };
   }
+  /**
+   * Выполняет рефреш учётных данных (внешним методом либо дефолтным OAuth-флоу).
+   *
+   * @param currentCredentials - текущие учётные данные.
+   * @param callback           - необязательный колбэк сохранения новых учётных данных.
+   * @returns Промис с новыми учётными данными.
+   */
   async refreshCredentials(currentCredentials, callback) {
     const CONTEXT = this;
     async function finalize(cred) {
@@ -1266,11 +1631,10 @@ var CredentialsProcessing = class {
     if (!currentCredentials?.token || !currentCredentials?.refreshToken) return finalize(CONTEXT.DEFAULT_CREDENTIALS);
     async function refreshCredentialsByDefault() {
       const { token, refreshToken } = currentCredentials;
-      const headers = new Headers();
-      headers.append(...Object.entries(CONTEXT.getHeadersForAuthorize(token)));
+      const headers = new Headers(Object.entries(CONTEXT.getHeadersForAuthorize(token || "")).map(([key, value]) => [key, `${value}`]));
       const body = new FormData();
       body.append("grant_type", "refresh_token");
-      body.append("refresh_token", refreshToken);
+      body.append("refresh_token", refreshToken || "");
       body.append("client_id", "oauth");
       body.append("client_secret", "secret");
       body.append("access_type", "offline");
@@ -1283,8 +1647,14 @@ var CredentialsProcessing = class {
       });
     }
     const newCredentials = typeof CONTEXT.refreshCredentialsByOuter === "function" ? await CONTEXT.refreshCredentialsByOuter(currentCredentials) : await refreshCredentialsByDefault();
-    return finalize(newCredentials);
+    return finalize(getIsOnlyAnObject(newCredentials) ? newCredentials : CONTEXT.DEFAULT_CREDENTIALS);
   }
+  /**
+   * Ожидает завершения рефреша токена (или запускает его флаг при необходимости).
+   *
+   * @param isNeedRefresh - выставить ли флаг «рефреш начат» при отсутствии активного рефреша.
+   * @returns Промис, который резолвится по завершении ожидания.
+   */
   async waitRefresh(isNeedRefresh) {
     return new Promise((resolve) => {
       if (!this.getIsTokenStartRefresh()) {
@@ -1300,10 +1670,16 @@ var CredentialsProcessing = class {
       }
     });
   }
+  /**
+   * Обрабатывает учётные данные: при необходимости рефрешит токен и возвращает актуальные данные.
+   *
+   * @param cred - текущие учётные данные.
+   * @returns Промис с актуальными учётными данными (с флагом isRefreshFailed при неудаче).
+   */
   async processCredentials(cred) {
     if (!cred.isNeedRefresh && !cred.isCatchCallbackProcess) return cred;
     const CONTEXT = this;
-    return CONTEXT.refreshCredentials(cred, (response) => CONTEXT.saveCredentials(response)).then(() => {
+    return CONTEXT.refreshCredentials(cred, (response) => CONTEXT.saveCredentials?.(response)).then(() => {
       return new Promise((resolve) => {
         setTimeout(async () => {
           const newCredentials = await CONTEXT.getCredentials();
@@ -1321,11 +1697,15 @@ var CredentialsProcessing = class {
 };
 var CredentialsProcessing_default = CredentialsProcessing;
 
-// src/Classes/RESTAPI/index.js
+// src/Classes/RESTAPI/index.ts
 function returnTheContext() {
   return this;
 }
 var RESTAPI = class extends ApiBase_default {
+  /** Функция показа сообщений пользователю (или null, если информирование отключено). */
+  sendMessage = null;
+  /** Обработчик учётных данных (создаётся при наличии настройки credentialsProcessing). */
+  credentialsProcessing;
   constructor(settings) {
     super(settings);
     const { sendMessage, credentialsProcessing } = settings || {};
@@ -1335,7 +1715,14 @@ var RESTAPI = class extends ApiBase_default {
       this.credentialsProcessing.getRESTAPIContext = returnTheContext.bind(this);
     }
   }
-  //! Основной (базовый) метод API, мультизапросы
+  /**
+   * Основной (базовый) метод API: выполняет мультизапрос (или одиночный запрос).
+   *
+   * @param inputRequests - путь, объект описания запроса или их массив.
+   * @param settings      - общие настройки запроса (формат ответа, тосты, сообщения и т.п.).
+   * @returns Промис с результатом (форма зависит от isResponseAsObject).
+   */
+  // ! Основной (базовый) метод API, мультизапросы
   async doRequest(inputRequests, settings) {
     if (typeof inputRequests !== "string" && typeof inputRequests !== "object") {
       return Promise.reject(new Error(this.BAD_REQUEST_DATA_TEXT));
@@ -1359,24 +1746,29 @@ var RESTAPI = class extends ApiBase_default {
       throw new Error("It is impossible to make a request!");
     }
     instance.setIsResponseAsObject(isResponseAsObject ?? true);
-    if (callback) instance.setCallback(callback);
+    if (typeof callback === "function") 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 getBodyAs = typeof item.getBodyAs === "string" ? item.getBodyAs : void 0;
         const finalIsGetBody = typeof item.isGetBody === "boolean" || typeof item.isGetBody === "string" ? item.isGetBody : isGetBody;
         const finalIsGetBodyFirst = finalIsGetBody === "first";
-        const checkResponseCallback = finalIsGetBodyFirst ? async (res, mesageOptions2) => API_CONTEXT.getResponseBody(await API_CONTEXT.checkResponseCode(res, mesageOptions2), getBodyAs) : async (res, mesageOptions2) => API_CONTEXT.checkResponseCode(res, mesageOptions2);
-        const callback2 = item.callback ? async (res) => item.callback(await checkResponseCallback(res, mesageOptions)) : async (res) => checkResponseCallback(res, mesageOptions);
-        return finalIsGetBody && !finalIsGetBodyFirst ? async (res) => API_CONTEXT.getResponseBody(await callback2(res), getBodyAs) : callback2;
+        const checkResponseCallback = finalIsGetBodyFirst ? async (res, options) => API_CONTEXT.getResponseBody(await API_CONTEXT.checkResponseCode(res, options), getBodyAs) : async (res, options) => API_CONTEXT.checkResponseCode(res, options);
+        const itemCallback = item.callback;
+        const callbackFn = typeof itemCallback === "function" ? async (res) => itemCallback(await checkResponseCallback(res, mesageOptions)) : async (res) => checkResponseCallback(res, mesageOptions);
+        return finalIsGetBody && !finalIsGetBodyFirst ? async (res) => API_CONTEXT.getResponseBody(await callbackFn(res), getBodyAs) : callbackFn;
       }
       async function getRequestItem(item, idx) {
-        const { type, ...partialRestFirst } = item;
+        const itemObj = getIsOnlyAnObject(item) ? item : { path: item };
+        const { type, ...partialRestFirst } = itemObj;
         const itemAfterRequestCreating = await (async () => {
-          const key = `createRequest_${type ?? "default"}`;
-          return key in API_CONTEXT ? API_CONTEXT[key](partialRestFirst, "doRequestMapping") : API_CONTEXT.createRequest_default(partialRestFirst, "doRequestMapping");
+          const key = `createRequest_${typeof type === "string" ? type : "default"}`;
+          const creator = key in API_CONTEXT ? API_CONTEXT[key] : void 0;
+          const result = typeof creator === "function" ? creator.call(API_CONTEXT, partialRestFirst, "doRequestMapping") : API_CONTEXT.createRequest_default(partialRestFirst, "doRequestMapping");
+          const awaited = await result;
+          return getIsOnlyAnObject(awaited) ? awaited : {};
         })();
         const { fullPath, api, path, query, queryParameters, ...partialRestSecond } = itemAfterRequestCreating;
         const {
@@ -1392,23 +1784,25 @@ var RESTAPI = class extends ApiBase_default {
           isNoToast,
           ...rest
         } = partialRestSecond;
+        const successMessagesArr = Array.isArray(successMessages) ? successMessages : void 0;
+        const errorMessagesArr = Array.isArray(errorMessages) ? errorMessages : void 0;
         const useSuccessMessageFlag = Boolean(
-          successMess || commonSuccessMessage || successMessages?.[idx] || CSMfromSettings || isToastResult || isToastFromSettings
+          successMess || commonSuccessMessage || successMessagesArr?.[idx] || CSMfromSettings || isToastResult || isToastFromSettings
         );
         const isUseSuccessToast = useSuccessMessageFlag && !isNoToast && !isNoToastFromSettings && !isNoToastSuccess && !isNTSFromSettings;
         const isUseErrorToast = !isNoToast && !isNoToastFromSettings && !isNoToastError && !isNTEFromSettings;
         const mesageOptions = {
-          successMess: successMess || commonSuccessMessage || successMessages?.[idx] || CSMfromSettings,
+          successMess: successMess || commonSuccessMessage || successMessagesArr?.[idx] || CSMfromSettings,
           successMessageType: successMessageType || SMTfromSettings,
-          errorMess: errorMess || commonErrorMessage || errorMessages?.[idx] || CEMfromSettings,
+          errorMess: errorMess || commonErrorMessage || errorMessagesArr?.[idx] || CEMfromSettings,
           isUseSuccessToast,
           isUseErrorToast,
           toastOptions: toastOptions || TOFomSettings
         };
         return {
           ...rest,
-          path: `${fullPath || await API_CONTEXT.getRootPath(api) + (path || "")}`,
-          //? Запускаем самовызывающуюся асинхронную ф-ю, ждем резолва промиса от нее
+          path: `${fullPath || await API_CONTEXT.getRootPath() + (typeof path === "string" ? path : "")}`,
+          // ? Запускаем самовызывающуюся асинхронную ф-ю, ждем резолва промиса от нее
           queryParameters: await (async () => {
             const queryParams = query || queryParameters || "";
             const preparedQueryParams = await API_CONTEXT.processQueryParams(queryParams);
@@ -1418,16 +1812,25 @@ var RESTAPI = class extends ApiBase_default {
           callback: getCallback(itemAfterRequestCreating, mesageOptions)
         };
       }
-      return output?.map((item, idx) => getRequestItem(item, idx));
+      return output.map((item, idx) => getRequestItem(item, idx));
     }
     return instance.request(await Promise.all(getRequests()));
   }
-  //! Метод API для одиночных запросов
+  /**
+   * Метод API для одиночных запросов: применяет крейтер по `type` и делегирует в {@link RESTAPI.doRequest}.
+   *
+   * @param requestSettings - объект описания одиночного запроса (с необязательным `type`).
+   * @returns Промис с результатом запроса.
+   */
+  // ! Метод API для одиночных запросов
   async doMonoRequest(requestSettings) {
     if (!getIsOnlyAnObject(requestSettings)) throw new Error(`${this.BAD_REQUEST_DATA_TEXT} [RESTAPI.doMonoRequest]`);
     const { type, ...requestSettingsRest } = requestSettings;
-    const doRequestArgs = type && this[`createRequest_${type}`] ? [...await this[`createRequest_${type}`](requestSettingsRest)] : [...await this.createRequest_default(requestSettingsRest)];
-    return this.doRequest(...doRequestArgs);
+    const key = `createRequest_${typeof type === "string" ? type : ""}`;
+    const creator = type && key in this ? this[key] : void 0;
+    const created = typeof creator === "function" ? await creator.call(this, requestSettingsRest) : await this.createRequest_default(requestSettingsRest);
+    const doRequestArgs = Array.isArray(created) ? created : [created];
+    return this.doRequest(doRequestArgs[0], doRequestArgs[1]);
   }
 };
 var RESTAPI_default = RESTAPI;
@@ -23053,17 +23456,6 @@ export {
   uuid,
   voidFn
 };
-//! При получении экземпляра, если sendMessage не является ф-ей,
-//! то это воспринимается как отключение шага информирования об ошибке запроса как такового
-//! Планируемая структура { headers, queryParameters, options }, где
-//!   - headers и options - объекты,
-//!   - queryParameters - строка, массив или объект
-//! ВНИМАНИЕ! Данный механизм рефреша принят на проекте finturfreactfrontend (админка)
-//! На кабинете он ТОЧНО НЕ ТАКОЙ
-//! currentCredentials передаются в формате класса! ({ token, refreshToken, expires })
-//! Наличие credentialsProcessing подключает ДОБАВЛЕНИЕ ТОКЕНОВ В ЗАПРОСЫ,
-//! НО по умолчанию НЕ добавляет флоу рефреша токенов
-//! (флоу рефреша подключается пропой isUseRefreshTokensPropcessing из credentialsProcessing)
 //! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
 //! чем указано в quantity - округлит по правилам округления
 //! чем указано в decimalPlaces - округлит по правилам округления