intelicoreact 1.8.68 → 2.0.0

package/dist/classes.cjs

@@ -0,0 +1,1464 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/classes.ts
+var classes_exports = {};
+__export(classes_exports, {
+  AbortableFetch: () => AbortableFetch_default,
+  AnimatedHandler: () => AnimatedHandler_default,
+  RESTAPI: () => RESTAPI_default
+});
+module.exports = __toCommonJS(classes_exports);
+
+// src/Classes/AbortableFetch.js
+var RESPONSE_AS_OBJECT_ALWAYS_VALUE = "always";
+var AbortableFetch = class {
+  #pathPrefix = null;
+  #method = null;
+  #queryParameters = null;
+  #headers = null;
+  #body = null;
+  #options = null;
+  #callback = null;
+  #catchCallback = null;
+  #everyPromiseCallback = null;
+  #isResponseAsObject = false;
+  constructor(input) {
+    if (input && (typeof input !== "object" || Array.isArray(input)))
+      throw new Error("Not valid input value!");
+    this.getPathPrefix = this.getPathPrefix.bind(this);
+    this.setPathPrefix = this.setPathPrefix.bind(this);
+    this.getMethod = this.getMethod.bind(this);
+    this.setMethod = this.setMethod.bind(this);
+    this.getQueryParameters = this.getQueryParameters.bind(this);
+    this.getQueryString = this.getQueryString.bind(this);
+    this.setQueryParameters = this.setQueryParameters.bind(this);
+    this.getHeaders = this.getHeaders.bind(this);
+    this.getHeadersObj = this.getHeadersObj.bind(this);
+    this.setHeaders = this.setHeaders.bind(this);
+    this.getBody = this.getBody.bind(this);
+    this.setBody = this.setBody.bind(this);
+    this.getOptions = this.getOptions.bind(this);
+    this.setOptions = this.setOptions.bind(this);
+    this.getCallback = this.getCallback.bind(this);
+    this.setCallback = this.setCallback.bind(this);
+    this.getCatchCallback = this.getCatchCallback.bind(this);
+    this.setCatchCallback = this.setCatchCallback.bind(this);
+    this.getEveryPromiseCallback = this.getEveryPromiseCallback.bind(this);
+    this.setEveryPromiseCallback = this.setEveryPromiseCallback.bind(this);
+    this.getIsResponseAsObject = this.getIsResponseAsObject.bind(this);
+    this.setIsResponseAsObject = this.setIsResponseAsObject.bind(this);
+    this.getProps = this.getProps.bind(this);
+    this.setProps = this.setProps.bind(this);
+    this.request = this.request.bind(this);
+    this.repeatRequest = this.repeatRequest.bind(this);
+    this.setProps(input || {});
+  }
+  request(props) {
+    if (!props || typeof props !== "object" && typeof props !== "string")
+      throw new Error("Not valid props value!");
+    const stringifyBody = (b) => b?.constructor === FormData ? b : JSON.stringify(b);
+    this.requestInput = props;
+    const requests = getRequestsArray.call(this, props);
+    if (!requests.length)
+      return Promise.reject(new Error("There are no any valid props"));
+    const abortController = new AbortController();
+    let externalRequest = Promise.all(
+      requests.map(async (item) => {
+        const safelyQuery = item.path.includes("?") ? `&${item.queryParameters.replace(/\?/g, "")}` : item.queryParameters;
+        let request = fetch(`${item.pathPrefix}${item.path}${safelyQuery}`, {
+          ...item.options,
+          method: item.method,
+          headers: item.headers,
+          ...item.body ? { body: stringifyBody(item.body) } : {},
+          signal: abortController.signal
+        }).then((response) => {
+          response.request = item;
+          return response;
+        }).catch(
+          (response) => Promise.resolve({
+            ok: false,
+            status: 0,
+            statusText: response,
+            request: item
+          })
+        );
+        if (this.#everyPromiseCallback && !item.isSkipEveryPromiseCallback)
+          request = request.then(
+            (response) => this.#everyPromiseCallback(response)
+          );
+        if (item.callback)
+          request = request.then((response) => item.callback(response));
+        if (this.#isResponseAsObject)
+          request = request.then((response) => ({ name: item.name, response }));
+        return request;
+      })
+    );
+    externalRequest = externalRequest.then(
+      (response) => response.length < 2 ? response[0] : response
+    );
+    if (this.#isResponseAsObject) {
+      externalRequest = externalRequest.then((response) => {
+        if (Array.isArray(props) && props.length > 1)
+          return response.reduce(
+            (ac, item) => ({ ...ac, [item.name]: item.response }),
+            {}
+          );
+        else
+          return this.#isResponseAsObject === RESPONSE_AS_OBJECT_ALWAYS_VALUE ? { [response.name]: response.response } : response.response;
+      });
+    }
+    externalRequest = externalRequest.then(
+      (response) => this.#callback ? this.#callback(response) : response
+    );
+    externalRequest = externalRequest.catch(
+      (error) => this.#catchCallback ? this.#catchCallback(error) : error
+    );
+    externalRequest.__proto__.abort = () => abortController.abort();
+    return externalRequest;
+    function getRequestsArray(input) {
+      const requestsArray = (() => {
+        if (typeof input === "string") return [{ path: input }];
+        return Array.isArray(input) ? [...input] : [input];
+      })();
+      return requestsArray.reduce((ac, item, index) => {
+        const itemObj = typeof item === "object" && item !== null && !Array.isArray(item) ? item : {};
+        const {
+          name,
+          path,
+          method,
+          queryParameters,
+          headers,
+          body,
+          options,
+          callback,
+          mergeProps,
+          isNoPathPrefix,
+          isSkipEveryPromiseCallback
+        } = itemObj;
+        const safelyMergeProps = mergeProps instanceof Object && !Array.isArray(mergeProps) ? mergeProps : {};
+        const getMergeProps = (key) => safelyMergeProps.all ?? safelyMergeProps[key];
+        if (!path || typeof path !== "string") return ac;
+        const {
+          name: omitName,
+          path: omitPath,
+          pathPrefix: omitPathPrefix,
+          method: omitMethod,
+          queryParameters: omitQueryParameters,
+          headers: omitHeaders,
+          body: omitBody,
+          options: omitOptions,
+          callback: omitCallback,
+          mergeProps: omitMergeProps,
+          ...optionsRest
+        } = options || {};
+        return [
+          ...ac,
+          {
+            path,
+            pathPrefix: getMergeProps("pathPrefix") === "onlyLocal" || isNoPathPrefix ? "" : this.#pathPrefix || "",
+            method: (() => {
+              if (getMergeProps("method") === "onlyLocal")
+                return method || "GET";
+              return getMergeProps("method") === "onlyGlobal" ? this.#method || "GET" : method || this.#method || "GET";
+            })(),
+            queryParameters: (() => {
+              if ((getMergeProps("queryParameters") ?? getMergeProps("query")) === "onlyLocal") {
+                return this.getQueryString(this.getQueryArray(queryParameters));
+              }
+              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 || {});
+              return getMergeProps("headers") === "onlyGlobal" ? this.getHeadersObj({ ...this.#headers || {} }) : this.getHeadersObj({
+                ...this.#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;
+            })(),
+            options: (() => {
+              if (getMergeProps("options") === "onlyLocal")
+                return { ...optionsRest || {} };
+              return getMergeProps("options") === "onlyGlobal" ? { ...this.#options || {} } : { ...this.#options || {}, ...optionsRest || {} };
+            })(),
+            callback,
+            isSkipEveryPromiseCallback,
+            ...this.getIsResponseAsObject() ? { name: name && typeof name === "string" ? name : index } : {}
+          }
+        ];
+      }, []);
+    }
+  }
+  repeatRequest() {
+    return this.request(this.requestInput);
+  }
+  // ***** getters and setters *****
+  getPathPrefix() {
+    return this.#pathPrefix;
+  }
+  setPathPrefix(value) {
+    if (value && typeof value !== "string")
+      throw new Error("Not valid pathPrefix value!");
+    this.#pathPrefix = value || null;
+  }
+  getMethod() {
+    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!");
+    this.#method = value || null;
+  }
+  getQueryParameters() {
+    return this.#queryParameters;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  getQueryArray(value) {
+    if (typeof value === "string") return value?.replace(/\?/g, "")?.split("&");
+    else if (Array.isArray(value))
+      return value.map((item) => item.replace(/\?/g, ""));
+    else if (typeof value === "object" && value !== null)
+      return Object.keys(value).filter((key) => key && value[key]).map((key) => `${key}=${value[key]}`);
+    else return [];
+  }
+  // eslint-disable-next-line class-methods-use-this
+  getQueryString(value) {
+    if (!Array.isArray(value))
+      throw new Error("Not valid query parameters value!");
+    return value.length ? `?${value.join("&")}` : "";
+  }
+  setQueryParameters(value) {
+    if (value && !Array.isArray(value))
+      throw new Error("Not valid query parameters value!");
+    this.#queryParameters = value || null;
+  }
+  getHeaders() {
+    return this.#headers;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  getHeadersObj(value) {
+    const headers = new Headers();
+    if (!value) return headers;
+    if (typeof value !== "object" || Array.isArray(value))
+      throw new Error("Not valid headers value!");
+    Object.keys(value).forEach((item) => {
+      headers.append(item, value[item]);
+    });
+    return headers;
+  }
+  setHeaders(value) {
+    if (value && (typeof value !== "object" || Array.isArray(value)))
+      throw new Error("Not valid headers value!");
+    this.#headers = value || null;
+  }
+  getBody() {
+    return this.#body;
+  }
+  setBody(value) {
+    this.#body = value;
+  }
+  getOptions() {
+    return this.#options;
+  }
+  setOptions(value) {
+    if (value && (typeof value !== "object" || Array.isArray(value)))
+      throw new Error("Not valid options value!");
+    this.#options = { ...value };
+  }
+  getCallback() {
+    return this.#callback;
+  }
+  setCallback(value) {
+    if (value && typeof value !== "function")
+      throw new Error("Not valid callback value!");
+    this.#callback = value || null;
+  }
+  getCatchCallback() {
+    return this.#catchCallback;
+  }
+  setCatchCallback(value) {
+    if (value && typeof value !== "function")
+      throw new Error("Not valid callback value!");
+    this.#catchCallback = value || null;
+  }
+  getEveryPromiseCallback() {
+    return this.#everyPromiseCallback;
+  }
+  setEveryPromiseCallback(value) {
+    if (value && typeof value !== "function")
+      throw new Error("Not valid callback value!");
+    this.#everyPromiseCallback = value || null;
+  }
+  getIsResponseAsObject() {
+    return this.#isResponseAsObject;
+  }
+  setIsResponseAsObject(value) {
+    this.#isResponseAsObject = typeof value !== "boolean" && value !== "always" ? Boolean(value) : value;
+  }
+  getProps() {
+    return {
+      pathPrefix: this.getPathPrefix() || null,
+      method: this.getMethod() || null,
+      queryParameters: this.getQueryParameters() || null,
+      headers: this.getHeaders() || null,
+      body: this.getBody() || null,
+      options: this.getOptions() || null,
+      callback: this.getCallback() || null,
+      everyPromiseCallback: this.getEveryPromiseCallback(),
+      // isAnywayRunCallback: this.getIsAnywayRunCallback(),
+      isResponseAsObject: this.getIsResponseAsObject()
+    };
+  }
+  setProps(input) {
+    const {
+      pathPrefix,
+      method,
+      queryParameters,
+      headers,
+      body,
+      options,
+      callback,
+      catchCallback,
+      everyPromiseCallback,
+      // isAnywayRunCallback,
+      isResponseAsObject
+    } = input;
+    if (pathPrefix) this.setPathPrefix(pathPrefix);
+    if (method) this.setMethod(method);
+    if (queryParameters)
+      this.setQueryParameters(this.getQueryArray(queryParameters));
+    if (headers) this.setHeaders(headers);
+    if (body) this.setBody(body);
+    if (options) this.setOptions(options);
+    if (callback) this.setCallback(callback);
+    if (catchCallback) this.setCatchCallback(catchCallback);
+    if (everyPromiseCallback)
+      this.setEveryPromiseCallback(everyPromiseCallback);
+    if (isResponseAsObject !== void 0)
+      this.setIsResponseAsObject(isResponseAsObject);
+  }
+};
+var AbortableFetch_default = AbortableFetch;
+
+// src/Classes/AnimatedHandler.js
+var DEFAULT_ANIMATION_DURATION = 200;
+var AnimatedHandler = class {
+  constructor(params) {
+    const {
+      type = "",
+      animationTarget,
+      animation,
+      settings,
+      hendler
+    } = params || {};
+    if (!animationTarget || !hendler) throw new Error("Bad input!");
+    const {
+      keyframes,
+      delay,
+      direction,
+      duration,
+      easing,
+      endDelay,
+      fill,
+      iterationStart,
+      iterations
+    } = animation || {};
+    return function(...args) {
+      const keyframesToUse = Array.isArray(keyframes) ? keyframes : [
+        { height: `${animationTarget.clientHeight}px`, opacity: 1 },
+        { height: "0", opacity: 0 }
+      ];
+      const durationToUse = duration || DEFAULT_ANIMATION_DURATION;
+      animationTarget.animate(keyframesToUse, animation);
+      return new Promise((res) => {
+        setTimeout(
+          () => res(hendler ? hendler(...args) : void 0),
+          durationToUse
+        );
+      });
+    };
+  }
+};
+var AnimatedHandler_default = AnimatedHandler;
+
+// src/Classes/RESTAPI/partials/AbortableFetch.js
+var RESPONSE_AS_OBJECT_ALWAYS_VALUE2 = "always";
+var AbortableFetch2 = class {
+  #pathPrefix = null;
+  #method = null;
+  #queryParameters = null;
+  #headers = null;
+  #body = null;
+  #options = null;
+  #callback = null;
+  #catchCallback = null;
+  #everyPromiseCallback = null;
+  #isResponseAsObject = false;
+  constructor(input) {
+    if (input && !getIsOnlyAnObject(input)) throw new Error("Not valid input value!");
+    this.getPathPrefix = this.getPathPrefix.bind(this);
+    this.setPathPrefix = this.setPathPrefix.bind(this);
+    this.getMethod = this.getMethod.bind(this);
+    this.setMethod = this.setMethod.bind(this);
+    this.getQueryParameters = this.getQueryParameters.bind(this);
+    this.getQueryString = this.getQueryString.bind(this);
+    this.setQueryParameters = this.setQueryParameters.bind(this);
+    this.getHeaders = this.getHeaders.bind(this);
+    this.getHeadersObj = this.getHeadersObj.bind(this);
+    this.setHeaders = this.setHeaders.bind(this);
+    this.getBody = this.getBody.bind(this);
+    this.setBody = this.setBody.bind(this);
+    this.getOptions = this.getOptions.bind(this);
+    this.setOptions = this.setOptions.bind(this);
+    this.getCallback = this.getCallback.bind(this);
+    this.setCallback = this.setCallback.bind(this);
+    this.getCatchCallback = this.getCatchCallback.bind(this);
+    this.setCatchCallback = this.setCatchCallback.bind(this);
+    this.getEveryPromiseCallback = this.getEveryPromiseCallback.bind(this);
+    this.setEveryPromiseCallback = this.setEveryPromiseCallback.bind(this);
+    this.getIsResponseAsObject = this.getIsResponseAsObject.bind(this);
+    this.setIsResponseAsObject = this.setIsResponseAsObject.bind(this);
+    this.getProps = this.getProps.bind(this);
+    this.setProps = this.setProps.bind(this);
+    this.request = this.request.bind(this);
+    this.repeatRequest = this.repeatRequest.bind(this);
+    this.setProps(input || {});
+  }
+  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);
+    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 = request.name;
+      return response;
+    };
+    let externalRequest = Promise.all(
+      requests.map(async (item) => {
+        const safelyQuery = item.path.includes("?") ? `&${item.queryParameters.replace(/\?/g, "")}` : item.queryParameters;
+        const internalRequest = fetch(`${item.pathPrefix}${item.path}${safelyQuery}`, {
+          ...item.options,
+          method: item.method,
+          headers: item.headers,
+          ...item.body ? { body: stringifyBody(item.body) } : {},
+          signal: abortController.signal
+        }).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
+            })
+          );
+        }).then(async (res) => {
+          return typeof ABORTABLE_FETCH_CONTEXT.#everyPromiseCallback === "function" && !item.isSkipEveryPromiseCallback ? await ABORTABLE_FETCH_CONTEXT.#everyPromiseCallback(res) : res;
+        }).then(async (res) => {
+          return await (typeof item.callback === "function" ? item.callback(res) : res);
+        }).then(async (res) => {
+          return { request: item, response: res, ...item.name ? { name: item.name } : {} };
+        });
+        internalRequest.__proto__.abort = () => abortController.abort();
+        return internalRequest;
+      })
+    ).then(async (resArr) => {
+      if (resArr.length < 1) {
+        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 }), {});
+      }
+      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);
+    }).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();
+    return externalRequest;
+    function getRequestsArray(input) {
+      const requestsArray = (() => {
+        if (typeof input === "string") return [{ path: input }];
+        return Array.isArray(input) ? [...input] : [input];
+      })();
+      return requestsArray.reduce((ac, item, index) => {
+        const itemObj = getIsOnlyAnObject(item) ? item : {};
+        const { name, path, method, queryParameters, headers, body, options, callback, mergeProps, isNoPathPrefix, isSkipEveryPromiseCallback } = itemObj;
+        const safelyMergeProps = getIsOnlyAnObject(mergeProps) ? mergeProps : {};
+        const getMergeProps = (key) => safelyMergeProps.all ?? safelyMergeProps[key];
+        if (!path || typeof path !== "string") return ac;
+        const {
+          name: omitName,
+          path: omitPath,
+          pathPrefix: omitPathPrefix,
+          method: omitMethod,
+          queryParameters: omitQueryParameters,
+          headers: omitHeaders,
+          body: omitBody,
+          options: omitOptions,
+          callback: omitCallback,
+          mergeProps: omitMergeProps,
+          ...optionsRest
+        } = options || {};
+        return [
+          ...ac,
+          {
+            path,
+            pathPrefix: getMergeProps("pathPrefix") === "onlyLocal" || isNoPathPrefix ? "" : this.#pathPrefix || "",
+            method: (() => {
+              if (getMergeProps("method") === "onlyLocal") return method || "GET";
+              return getMergeProps("method") === "onlyGlobal" ? this.#method || "GET" : method || this.#method || "GET";
+            })(),
+            queryParameters: (() => {
+              if ((getMergeProps("queryParameters") ?? getMergeProps("query")) === "onlyLocal") {
+                return this.getQueryString(this.getQueryArray(queryParameters));
+              }
+              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 || {});
+              return getMergeProps("headers") === "onlyGlobal" ? this.getHeadersObj({ ...this.#headers || {} }) : this.getHeadersObj({
+                ...this.#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;
+            })(),
+            options: (() => {
+              if (getMergeProps("options") === "onlyLocal") return { ...optionsRest || {} };
+              return getMergeProps("options") === "onlyGlobal" ? { ...this.#options || {} } : { ...this.#options || {}, ...optionsRest || {} };
+            })(),
+            callback,
+            isSkipEveryPromiseCallback,
+            ...this.getIsResponseAsObject() ? { name: name && typeof name === "string" ? name : index } : {}
+          }
+        ];
+      }, []);
+    }
+  }
+  repeatRequest() {
+    return this.request(this.requestInput);
+  }
+  // ***** getters and setters *****
+  getPathPrefix() {
+    return this.#pathPrefix;
+  }
+  setPathPrefix(value) {
+    if (value && typeof value !== "string") throw new Error("Not valid pathPrefix value!");
+    this.#pathPrefix = value || null;
+  }
+  getMethod() {
+    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!");
+    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 [];
+  }
+  getQueryString(value) {
+    if (!value) return "";
+    if (!Array.isArray(value)) throw new Error("Not valid query parameters value!");
+    return value.length ? `?${value.join("&")}` : "";
+  }
+  setQueryParameters(value) {
+    if (value && !Array.isArray(value)) throw new Error("Not valid query parameters value!");
+    this.#queryParameters = value || null;
+  }
+  getHeaders() {
+    return this.#headers;
+  }
+  getHeadersObj(obj) {
+    const headers = new Headers();
+    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]);
+    });
+    return headers;
+  }
+  setHeaders(value) {
+    if (value && (typeof value !== "object" || Array.isArray(value))) throw new Error("Not valid headers value!");
+    this.#headers = value || null;
+  }
+  getBody() {
+    return this.#body;
+  }
+  setBody(value) {
+    this.#body = value;
+  }
+  getOptions() {
+    return this.#options;
+  }
+  setOptions(value) {
+    if (value && (typeof value !== "object" || Array.isArray(value))) throw new Error("Not valid options value!");
+    this.#options = { ...value };
+  }
+  getCallback() {
+    return this.#callback;
+  }
+  setCallback(value) {
+    if (value && typeof value !== "function") throw new Error("Not valid callback value!");
+    this.#callback = value || null;
+  }
+  getCatchCallback() {
+    return this.#catchCallback;
+  }
+  setCatchCallback(value) {
+    if (value && typeof value !== "function") throw new Error("Not valid callback value!");
+    this.#catchCallback = value || null;
+  }
+  getEveryPromiseCallback() {
+    return this.#everyPromiseCallback;
+  }
+  setEveryPromiseCallback(value) {
+    if (value && typeof value !== "function") throw new Error("Not valid callback value!");
+    this.#everyPromiseCallback = value || null;
+  }
+  getIsResponseAsObject() {
+    return this.#isResponseAsObject;
+  }
+  setIsResponseAsObject(value) {
+    this.#isResponseAsObject = typeof value !== "boolean" && value !== "always" ? Boolean(value) : value;
+  }
+  getProps() {
+    return {
+      pathPrefix: this.getPathPrefix() || null,
+      method: this.getMethod() || null,
+      queryParameters: this.getQueryParameters() || null,
+      headers: this.getHeaders() || null,
+      body: this.getBody() || null,
+      options: this.getOptions() || null,
+      callback: this.getCallback() || null,
+      everyPromiseCallback: this.getEveryPromiseCallback(),
+      // isAnywayRunCallback: this.getIsAnywayRunCallback(),
+      isResponseAsObject: this.getIsResponseAsObject()
+    };
+  }
+  setProps(input) {
+    const {
+      pathPrefix,
+      method,
+      queryParameters,
+      headers,
+      body,
+      options,
+      callback,
+      catchCallback,
+      everyPromiseCallback,
+      // isAnywayRunCallback,
+      isResponseAsObject
+    } = input;
+    if (pathPrefix) this.setPathPrefix(pathPrefix);
+    if (method) this.setMethod(method);
+    if (queryParameters) this.setQueryParameters(this.getQueryArray(queryParameters));
+    if (headers) this.setHeaders(headers);
+    if (body) this.setBody(body);
+    if (options) this.setOptions(options);
+    if (callback) this.setCallback(callback);
+    if (catchCallback) this.setCatchCallback(catchCallback);
+    if (everyPromiseCallback) this.setEveryPromiseCallback(everyPromiseCallback);
+    if (isResponseAsObject !== void 0) this.setIsResponseAsObject(isResponseAsObject);
+  }
+};
+var AbortableFetch_default2 = AbortableFetch2;
+
+// src/Classes/RESTAPI/partials/_utils.js
+function getIsOnlyAnObject(input) {
+  return typeof input === "object" && // "отбивает" примитивы и функции
+  input instanceof Object && // "отбивает" null
+  !Array.isArray(input) && // "отбивает" массивы
+  !(input instanceof Set) && // "отбивает" сеты
+  !(input instanceof Map);
+}
+var 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;
+};
+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 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) {
+  const API_CONTEXT = this;
+  const CREDENTIALS_CONTEXT = API_CONTEXT.credentialsProcessing;
+  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(
+      async () => CREDENTIALS_CONTEXT.processCredentials(await CREDENTIALS_CONTEXT.getCredentials())
+    ) : cred;
+  }
+  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?.() || {};
+  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]");
+  }
+  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-ку, попробовали получить/обновить креды)
+        ...credentials.token ? CREDENTIALS_CONTEXT?.getHeadersForAuthorize?.(credentials.token) || {} : {}
+      },
+      queryParameters: await API_CONTEXT.processQueryParams(queryParamsToAbortableFetchInstance),
+      //? Опции по умолчанию
+      options: {
+        mode: "cors",
+        redirect: "follow",
+        ...optionsToAbortableFetchInstance
+      },
+      //? Каждый запрос (каждый запрос мультизапроса), сделаный методом 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;
+          if (isUseErrorToast) {
+            API_CONTEXT.sendMessage?.(API_CONTEXT.NO_INET, request.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));
+      },
+      //? Если хоть один запрос из пачки будет зареджекчен, зареджектится вся пачка.
+      //? В этом случае будет выполнен этот колбэк
+      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),
+              isCatchCallbackProcess: isDoRefresh
+            });
+            ABORTABLE_FETCH_INSTANCE.setHeaders({
+              ...ABORTABLE_FETCH_INSTANCE.getHeaders(),
+              ...newCredentials?.token ? { Authorization: `Bearer ${newCredentials?.token}` } : {}
+            });
+            if (newCredentials.token) return ABORTABLE_FETCH_INSTANCE.repeatRequest();
+            return Promise.reject(res);
+          });
+        }
+        return Promise.reject(res);
+      }
+    })
+  );
+}
+
+// src/Classes/RESTAPI/partials/Utils.js
+var Utils = class {
+  //! Могут содержаться НЕасинхронные методы!
+  //? Ф-я normalizeQueryParams является нормализатором сложных квери
+  //? Например: &key1=&&&===&&&key2====&&&&&&&&key3=....
+  //? Для корректной работы на вход нужно подавать НЕ кодированные значения
+  //? По умолчанию выходные значения квери-параметров НЕ кодируются
+  normalizeQueryParams(queryParams, settings) {
+    if (settings && !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 (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}`);
+    }
+  }
+};
+var Utils_default = Utils;
+
+// src/Classes/RESTAPI/partials/ApiUtils.js
+var ApiUtils = class extends Utils_default {
+  constructor(settings) {
+    super();
+    const { utils } = settings || {};
+    if (getIsOnlyAnObject(utils)) addCustomMethods.call(this, utils);
+  }
+  //? Планируется, что метод будет использоваться неизменно, однако технически его можно перегрузить на экземпляре
+  //? Метод не планировался как асинхронный,
+  //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+  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) {
+    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;
+    })();
+    try {
+      return await executor.call(response);
+    } catch {
+      console.log("Failed to extract the body");
+      return null;
+    }
+  }
+  //! Обработчик структуры для ошибки (не рендер месседжа, а имеено формирование ошибки),
+  //? Планируется, что метод будет перегружаться на экземпляре,
+  //? т.к. на разных проектах могут быть разные структуры тела ответа для ошибки
+  //? Метод не планировался как асинхронный,
+  //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+  //? res - уже тело ответа
+  async getErrorMessage(res) {
+    return res;
+  }
+  //? Планируется, что метод будет использоваться неизменно, однако технически его можно перегрузить на экземпляре
+  //? Метод планировался как асинхронный
+  async checkResponseCode(res, settings) {
+    if (typeof this.sendMessage !== "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)));
+    try {
+      this.sendMessage(message, settings, await getResponseClone(res));
+    } catch (_error) {
+    }
+    return res;
+  }
+  //? Суть метода:
+  //? передать из вне структуры, которые будут использоваться для КАЖДОГО запроса сделанного экземпляром RESTAPI
+  //! Данные затрут прочие настройки КРОМЕ данных по логике авторизации
+  //? Планируется, что метод будет перегружаться на экземпляре
+  //? Метод не планировался как асинхронный,
+  //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+  async addAsCommon() {
+    return {};
+  }
+  //! Обработчик квери-параметров для общего процессинга,
+  //! Например для кодирования decodeURIComponent или/и приведения в формат массива
+  //? Планируется, что метод будет перегружаться на экземпляре,
+  //? т.к. на разных проектах могут быть разные договоренности по форматам
+  //? Метод не планировался как асинхронный,
+  //? однако ввиду того что он может быть перегружен на экземпляре асинхронность предусматривается
+  async processQueryParams(queryParams) {
+    return queryParams;
+  }
+};
+var ApiUtils_default = ApiUtils;
+
+// src/Classes/RESTAPI/partials/ApiRequestCreators.js
+var PREFIX_OF_CLASS_UTILS = "createRequest_";
+var ApiRequestCreators = class extends ApiUtils_default {
+  constructor(settings) {
+    super(settings);
+    const { requestsCreators } = settings || {};
+    if (getIsOnlyAnObject(requestsCreators)) addCustomMethods.call(this, requestsCreators, PREFIX_OF_CLASS_UTILS);
+  }
+  //? При типе toJson пользовательский callback на вход получит тело ответа реализованное методом Response.json()
+  //? независимо от насторойки isGetBody
+  async createRequest_toJson(props, variant) {
+    const safelyProps = omitKeys(props, ["getBodyAs"]);
+    return this.splitProperties(
+      {
+        ...safelyProps,
+        isGetBody: false,
+        callback: async (res) => {
+          const output = await this.getResponseBody(res, "json");
+          return await (safelyProps.callback?.(output) ?? output);
+        }
+      },
+      variant
+    );
+  }
+  //? При типе toJsonAdvanced пользовательский callback на вход получит структуру { response, result },
+  //? где response - объект Response, result - тело ответа реализованное методом Response.json()
+  //? независимо от насторойки isGetBody
+  async createRequest_toJsonAdvanced(props, variant) {
+    const safelyProps = omitKeys(props, ["getBodyAs"]);
+    return this.splitProperties(
+      {
+        ...safelyProps,
+        isGetBody: false,
+        callback: async (res) => {
+          const output = {
+            response: res,
+            result: await this.getResponseBody(await getResponseClone(res), "json")
+          };
+          return await (safelyProps.callback?.(output) ?? output);
+        }
+      },
+      variant
+    );
+  }
+  //? При типе blob пользовательский callback на вход получит тело ответа реализованное методом Response.blob(),
+  //? независимо от насторойки isGetBody
+  async createRequest_blob(props, variant) {
+    const safelyProps = omitKeys(props, ["getBodyAs"]);
+    return this.splitProperties(
+      {
+        ...safelyProps,
+        isGetBody: false,
+        callback: async (res) => {
+          const output = await this.getResponseBody(await getResponseClone(res), "blob");
+          return await (safelyProps.callback?.(output) ?? output);
+        }
+      },
+      variant
+    );
+  }
+  //? При типе testBadResponse пользовательский callback на вход получит объект Response в 401-м статусе
+  //? независимо независимо вообще ни от чего
+  async createRequest_testBadResponse(props, variant) {
+    return this.splitProperties(
+      {
+        ...props,
+        callback: async () => Promise.resolve(
+          new Response(JSON.stringify({ errors: [{ message: "test bad Response" }] }), {
+            status: 401,
+            statusText: "test bad Response",
+            headers: (() => {
+              const headers = new Headers();
+              headers.append("content-type", "application/json");
+              return headers;
+            })()
+          })
+        ).then((res) => props.callback?.(res) ?? res)
+      },
+      variant
+    );
+  }
+  //? По умолчанию пользовательский 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
+var ApiBase = class extends ApiRequestCreators_default {
+  constructor(settings) {
+    super(settings);
+    const {
+      API_PATH,
+      BAD_REQUEST_DATA_TEXT = "Bad request data",
+      DEFAULT_SUCCESS_MESSAGE = "Success",
+      DEFAULT_ERROR_MESSAGE = "Something wrong, try again",
+      NO_INET = "Please check your network connection and reload page",
+      REJECT_CODES = [],
+      ...customConstants
+    } = settings.constants || {};
+    if (typeof API_PATH !== "string") throw new Error("No API_PATH [ApiBase constructor]");
+    if (typeof BAD_REQUEST_DATA_TEXT !== "string" || typeof DEFAULT_SUCCESS_MESSAGE !== "string" || typeof DEFAULT_ERROR_MESSAGE !== "string" || typeof NO_INET !== "string" || !Array.isArray(REJECT_CODES) || !REJECT_CODES.every((i) => typeof i === "number")) {
+      throw new Error("Bad input data [ApiBase constructor]");
+    }
+    this.API_PATH = API_PATH;
+    this.BAD_REQUEST_DATA_TEXT = BAD_REQUEST_DATA_TEXT;
+    this.DEFAULT_SUCCESS_MESSAGE = DEFAULT_SUCCESS_MESSAGE;
+    this.DEFAULT_ERROR_MESSAGE = DEFAULT_ERROR_MESSAGE;
+    this.NO_INET = NO_INET;
+    this.REJECT_CODES = REJECT_CODES;
+    Object.keys(customConstants).forEach((key) => {
+      this[key] = customConstants[key];
+    });
+  }
+};
+var ApiBase_default = ApiBase;
+
+// src/Classes/RESTAPI/partials/CredentialsProcessing.js
+function decodeJWT(token) {
+  try {
+    const payload = token.split(".")[1];
+    return JSON.parse(atob(payload));
+  } catch (e) {
+    return null;
+  }
+}
+var CredentialsProcessing = class {
+  constructor(settings) {
+    const { credentialsProcessing } = settings;
+    const {
+      //? Для корректной работы установки токенов в запросы от API
+      //? нужно передавать методы getCredentials и getHeadersForAuthorize
+      getCredentials,
+      getHeadersForAuthorize,
+      //? На вход получит токен, должна вернуть объект для коструктора Headers
+      //? Так же опционально можно передавать
+      importCredentials,
+      //? если он передается, то он будет применяться к выводу от вызова getCredentials
+      saveCredentials,
+      //? можно будет найти в объекте credentialsProcessing, чтобы использовать кастомными методами
+      //! Либо вызов getCredentials, либо цепочка вызовов importCredentials(getCredentials())
+      //! должна возвращать требуемую классом структуру
+      //! Класс требует структуры
+      //!   - { token }, если флоу рефреш токена НЕ используется
+      //!   - { token, refreshToken, expires }, если используется флоу рефреш токена
+      // *********
+      //? Подключает флоу рефреша токенов
+      isUseRefreshTokensPropcessing = false,
+      //! Для корректной работы флоу рефреша токенов передача метода saveCredentials становится ОБЯЗАТЕЛЬНОЙ
+      //? Так же для корректной работы флоу рефреша токенов нужно
+      //?   - либо
+      refreshCredentials,
+      //! метод должен возвращать такую же структуру как и метод getCredentials,
+      //? на вход получит текущие креды, к выходу будет применен importCredentials, если этот метод передавался
+      //?   - либо
+      REFRESH_TOKEN_PATH,
+      //! REFRESH_TOKEN_PATH передается ПОЛНОСТЬЮ (глобальная адресация)!
+      CODES_USING_THE_REFRESH_ATTEMPT,
+      //? указывает по каким кодам ответа триггериться рефреш, массив чисел
+      //? Опционально
+      REFRESH_TOKEN_FLAG = "refreshTokenFlag",
+      INTERVAL_FOR_CHECKING_TOKEN_UPDATE = 50,
+      // ms
+      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;
+    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;
+    }
+  }
+  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 (!getIsOnlyAnObject(credentials)) credentials = {};
+    const token = credentials.token || null;
+    if (token && !isCatchCallbackProcess) {
+      let decoded;
+      try {
+        decoded = decodeJWT(token);
+      } catch {
+        decoded = null;
+      }
+      const currentTime = Date.now() / 1e3;
+      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?.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 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"
+      });
+    }
+    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?.token) {
+            newCredentials.isRefreshFailed = true;
+            setTimeout(() => {
+              CONTEXT?.callbackAfterRejectRefresh?.();
+            }, 0);
+          }
+          resolve(newCredentials);
+        }, 0);
+      });
+    });
+  }
+};
+var CredentialsProcessing_default = CredentialsProcessing;
+
+// src/Classes/RESTAPI/index.js
+function returnTheContext() {
+  return this;
+}
+var RESTAPI = class extends ApiBase_default {
+  constructor(settings) {
+    super(settings);
+    const { sendMessage, credentialsProcessing } = settings || {};
+    this.sendMessage = typeof sendMessage === "function" ? sendMessage : null;
+    if (getIsOnlyAnObject(credentialsProcessing)) {
+      this.credentialsProcessing = new CredentialsProcessing_default(settings);
+      this.credentialsProcessing.getRESTAPIContext = returnTheContext.bind(this);
+    }
+  }
+  //! Основной (базовый) метод API, мультизапросы
+  async doRequest(inputRequests, settings) {
+    if (typeof inputRequests !== "string" && typeof inputRequests !== "object") {
+      return Promise.reject(new Error(this.BAD_REQUEST_DATA_TEXT));
+    }
+    const API_CONTEXT = this;
+    const { isResponseAsObject, isGetBody, callback, ...partialRestSettings } = settings || {};
+    const {
+      commonSuccessMessage: CSMfromSettings,
+      commonErrorMessage: CEMfromSettings,
+      successMessageType: SMTfromSettings,
+      isToastResult: isToastFromSettings,
+      toastOptions: TOFomSettings,
+      isNoToastSuccess: isNTSFromSettings,
+      isNoToastError: isNTEFromSettings,
+      isNoToast: isNoToastFromSettings,
+      successMessages,
+      errorMessages
+    } = partialRestSettings || {};
+    const instance = await getInstanceOfFetchSystem.call(this);
+    if (!instance) {
+      throw new Error("It is impossible to make a request!");
+    }
+    instance.setIsResponseAsObject(isResponseAsObject ?? true);
+    if (callback) instance.setCallback(callback);
+    function getRequests() {
+      let output;
+      if (typeof inputRequests === "string") output = [{ path: inputRequests }];
+      else output = Array.isArray(inputRequests) ? inputRequests : [inputRequests];
+      function getCallback(item, mesageOptions) {
+        const { getBodyAs } = item;
+        const finalIsGetBody = typeof item.isGetBody === "boolean" || typeof item.isGetBody === "string" ? item.isGetBody : isGetBody;
+        const finalIsGetBodyFirst = finalIsGetBody === "first";
+        const checkResponseCallback = finalIsGetBodyFirst ? async (res, 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;
+      }
+      async function getRequestItem(item, idx) {
+        const { type, ...partialRestFirst } = item;
+        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 { fullPath, api, path, query, queryParameters, ...partialRestSecond } = itemAfterRequestCreating;
+        const {
+          successMess,
+          commonSuccessMessage,
+          successMessageType,
+          errorMess,
+          commonErrorMessage,
+          isToastResult,
+          toastOptions,
+          isNoToastSuccess,
+          isNoToastError,
+          isNoToast,
+          ...rest
+        } = partialRestSecond;
+        const useSuccessMessageFlag = Boolean(
+          successMess || commonSuccessMessage || successMessages?.[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,
+          successMessageType: successMessageType || SMTfromSettings,
+          errorMess: errorMess || commonErrorMessage || errorMessages?.[idx] || CEMfromSettings,
+          isUseSuccessToast,
+          isUseErrorToast,
+          toastOptions: toastOptions || TOFomSettings
+        };
+        return {
+          ...rest,
+          path: `${fullPath || await API_CONTEXT.getRootPath(api) + (path || "")}`,
+          //? Запускаем самовызывающуюся асинхронную ф-ю, ждем резолва промиса от нее
+          queryParameters: await (async () => {
+            const queryParams = query || queryParameters || "";
+            const preparedQueryParams = await API_CONTEXT.processQueryParams(queryParams);
+            return preparedQueryParams;
+          })(),
+          mesageOptions,
+          callback: getCallback(itemAfterRequestCreating, mesageOptions)
+        };
+      }
+      return output?.map((item, idx) => getRequestItem(item, idx));
+    }
+    return instance.request(await Promise.all(getRequests()));
+  }
+  //! Метод 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);
+  }
+};
+var RESTAPI_default = RESTAPI;
+//! При получении экземпляра, если sendMessage не является ф-ей,
+//! то это воспринимается как отключение шага информирования об ошибке запроса как такового
+//! Планируемая структура { headers, queryParameters, options }, где
+//!   - headers и options - объекты,
+//!   - queryParameters - строка, массив или объект
+//! ВНИМАНИЕ! Данный механизм рефреша принят на проекте finturfreactfrontend (админка)
+//! На кабинете он ТОЧНО НЕ ТАКОЙ
+//! currentCredentials передаются в формате класса! ({ token, refreshToken, expires })
+//! Наличие credentialsProcessing подключает ДОБАВЛЕНИЕ ТОКЕНОВ В ЗАПРОСЫ,
+//! НО по умолчанию НЕ добавляет флоу рефреша токенов
+//! (флоу рефреша подключается пропой isUseRefreshTokensPropcessing из credentialsProcessing)
+//# sourceMappingURL=classes.cjs.map