larapi 0.2.44 → 0.2.46

package/dist/index.mjs

@@ -0,0 +1,952 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/Core.ts
+import EventEmitter from "easy-event-emitter";
+var Core = class {
+  constructor(context) {
+    __publicField(this, "cache");
+    __publicField(this, "initData");
+    __publicField(this, "events");
+    __publicField(this, "config");
+    __publicField(this, "headers", {});
+    this.events = new EventEmitter();
+    this.config = {
+      host: "http://127.0.0.1/"
+    };
+    this.cache = {};
+    this.initData = {};
+    this.setConfig = this.setConfig.bind(this);
+    this.getConfig = this.getConfig.bind(this);
+    this.setHost = this.setHost.bind(this);
+    this.setInitData = this.setInitData.bind(this);
+    this.triggerByCacheGroup = this.triggerByCacheGroup.bind(this);
+    this.clearCacheGroup = this.clearCacheGroup.bind(this);
+    this.updateCacheGroup = this.updateCacheGroup.bind(this);
+    this.setGlobalInitData = this.setGlobalInitData.bind(this);
+    if (context) {
+      Object.assign(this, {
+        config: context == null ? void 0 : context.config,
+        events: context == null ? void 0 : context.events,
+        cache: context == null ? void 0 : context.cache,
+        initData: context == null ? void 0 : context.initData,
+        headers: context.headers
+      });
+    }
+  }
+  setConfig(config) {
+    this.config = config;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getCache(key) {
+    if (this.cache[key]) {
+      if ((/* @__PURE__ */ new Date()).getTime() <= this.cache[key].time + 36e8) {
+        return this.cache[key].data;
+      } else {
+        delete this.cache[key];
+      }
+    }
+  }
+  isJsonString(str) {
+    try {
+      JSON.parse(str);
+    } catch (e) {
+      return false;
+    }
+    return true;
+  }
+  compileRevivers() {
+    const fieldRevivers = {};
+    const objectRevivers = [];
+    const replace = this.config.dataReviver;
+    if (!replace) return { fieldRevivers, objectRevivers };
+    for (const [key, fn] of Object.entries(replace)) {
+      if (typeof fn !== "function") continue;
+      if (key.includes("&")) {
+        objectRevivers.push({
+          keys: new Set(key.split("&")),
+          fn
+        });
+      } else {
+        fieldRevivers[key] = fn;
+      }
+    }
+    return { fieldRevivers, objectRevivers };
+  }
+  applyObjectRevivers(value, objectRevivers, depth = 0, isArrayItem = false) {
+    if (!value || typeof value !== "object") {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        value[i] = this.applyObjectRevivers(value[i], objectRevivers, depth + 1, true);
+      }
+      return value;
+    }
+    let obj = value;
+    const shouldApply = depth === 0 || isArrayItem;
+    if (shouldApply) {
+      for (const rule of objectRevivers) {
+        const keys = Object.keys(obj);
+        if (rule.keys.size > keys.length) continue;
+        let match = true;
+        for (const k of rule.keys) {
+          if (!(k in obj)) {
+            match = false;
+            break;
+          }
+        }
+        if (match) {
+          obj = rule.fn(obj);
+        }
+      }
+    }
+    for (const k of Object.keys(obj)) {
+      obj[k] = this.applyObjectRevivers(obj[k], objectRevivers, depth + 1, false);
+    }
+    return obj;
+  }
+  dataPrepare(data) {
+    const json = JSON.stringify(data);
+    return this.jsonParse(json);
+  }
+  jsonParse(str) {
+    if (typeof this.config.reviver === "function") {
+      return JSON.parse(str, this.config.reviver);
+    }
+    const { fieldRevivers, objectRevivers } = this.compileRevivers();
+    const data = JSON.parse(str, (key, value) => {
+      const reviver = fieldRevivers[key];
+      return reviver ? reviver(value) : value;
+    });
+    return this.applyObjectRevivers(data, objectRevivers);
+  }
+  setHost(host) {
+    this.config.host = host;
+  }
+  setHeader(name, value) {
+    this.headers[name] = value;
+    this.events.emit("header-update", {
+      name,
+      value
+    });
+  }
+  getHeader(name) {
+    return this.headers[name];
+  }
+  getHeaders() {
+    return Object.entries(this.headers).map(([name, value]) => ({ name, value }));
+  }
+  hasHeader(name) {
+    return this.headers[name] ? true : false;
+  }
+  deleteHeader(name) {
+    delete this.headers[name];
+  }
+  setCache(key, data, group) {
+    this.cache[key] = {
+      time: (/* @__PURE__ */ new Date()).getTime(),
+      data,
+      group
+    };
+  }
+  groupFromArray(groups, callback, withoutSplit = false) {
+    const currentCallback = (group) => {
+      if (typeof group === "string" && !withoutSplit) {
+        const params = group.split(".");
+        const current = params.shift();
+        callback(current, params);
+      } else {
+        callback(group);
+      }
+    };
+    if (Array.isArray(groups)) {
+      groups.map(currentCallback);
+    } else if (typeof groups === "string") {
+      currentCallback(groups);
+    }
+  }
+  triggerByCacheGroup(groups) {
+    this.groupFromArray(groups, (group) => this.events.emit("trigger-request-by-cache-" + group, void 0));
+  }
+  clearCacheGroup(groups, data, fieldKey = "id") {
+    this.groupFromArray(groups, (group) => {
+      if (data) {
+        const clear = (cacheData) => {
+          if (fieldKey && (cacheData == null ? void 0 : cacheData[fieldKey]) === (data == null ? void 0 : data[fieldKey]) || fieldKey === null) {
+            for (const key in cacheData) {
+              if (key in data) {
+                return false;
+              }
+            }
+          }
+          return true;
+        };
+        for (const key in this.cache) {
+          if (this.cache[key].group === group) {
+            if (Array.isArray(this.cache[key].data)) {
+              this.cache[key].data = Object.values(this.cache[key].data).filter(clear);
+            } else {
+              if (!clear(this.cache[key].data))
+                delete this.cache[key];
+            }
+          }
+        }
+      } else {
+        for (const key in this.cache) {
+          if (this.cache[key].group === group) {
+            delete this.cache[key];
+          }
+        }
+      }
+    });
+  }
+  setDataTree(obj, path, val) {
+    const keys = path.split(".");
+    const lastKey = keys.pop();
+    const lastObj = keys.reduce(
+      (obj2, key) => obj2[key] = obj2[key] || {},
+      obj
+    );
+    if (typeof lastKey === "string") {
+      lastObj[lastKey] = val;
+    }
+    return obj;
+  }
+  updateCacheGroup(groups, data, fieldKey = "id") {
+    const update = (cacheData) => {
+      const retData = cacheData;
+      const fieldList = fieldKey.split(".");
+      if (fieldList.length > 1) {
+        for (const key of fieldList) {
+          cacheData = cacheData[key];
+        }
+      }
+      if (fieldKey && cacheData[fieldKey] === data[fieldKey] || fieldKey === null) {
+        for (const key in cacheData) {
+          if (key in data) {
+            cacheData[key] = data[key];
+          }
+        }
+      }
+      return retData;
+    };
+    this.groupFromArray(groups, (group, params) => {
+      for (const key in this.cache) {
+        if (this.cache[key].group === group) {
+          if (Array.isArray(this.cache[key].data)) {
+            this.cache[key].data = Object.values(this.cache[key].data).map(update);
+          } else {
+            this.cache[key].data = update(this.cache[key].data);
+          }
+        }
+      }
+    });
+  }
+  appendCacheGroup(group, data) {
+  }
+  getCacheByIndex(index) {
+    return this.cache[index];
+  }
+  deleteCache(key) {
+    if (!this.cache[key])
+      return;
+    const group = this.cache[key].group;
+    if (group) {
+      this.clearCacheGroup(group);
+    }
+    delete this.cache[key];
+  }
+  setGlobalInitData(name, data) {
+    this.initData[name] = data;
+  }
+  setInitData(data) {
+    this.initData = data;
+  }
+};
+var Core_default = Core;
+
+// src/Http.ts
+import md5 from "md5";
+
+// src/Queue.ts
+var _Queue = class _Queue {
+  constructor(http) {
+    __publicField(this, "queue", _Queue._Queue);
+    __publicField(this, "http");
+    this.http = http;
+    this.has = this.has.bind(this);
+    this.get = this.get.bind(this);
+    this.clear = this.clear.bind(this);
+    this.push = this.push.bind(this);
+  }
+  has(request) {
+    return request in this.queue;
+  }
+  get(request) {
+    return this.has(request) ? this.queue[request] : void 0;
+  }
+  clear(request) {
+    if (this.has(request)) {
+      delete this.queue[request];
+    }
+  }
+  push(request) {
+    const refInstance = this.get(request);
+    if (!refInstance) {
+      this.queue[request] = this.http;
+    } else {
+      refInstance == null ? void 0 : refInstance.addListener("api-request-success", this.http.handleSuccess);
+      refInstance == null ? void 0 : refInstance.addListener("api-request-error", this.http.handleError);
+      refInstance == null ? void 0 : refInstance.addListener("api-request-fail", this.http.handleFail);
+      refInstance == null ? void 0 : refInstance.addListener("api-request-complete", this.http.handleComplete);
+      refInstance == null ? void 0 : refInstance.addListener("api-request-abort", this.http.handleAbort);
+    }
+    return refInstance instanceof Http_default;
+  }
+};
+__publicField(_Queue, "_Queue", {});
+var Queue = _Queue;
+var Queue_default = Queue;
+
+// src/Http.ts
+import EventEmitter2 from "easy-event-emitter";
+var Http = class _Http extends Core_default {
+  constructor(method, params, context) {
+    super(context);
+    __publicField(this, "cacheIndex");
+    __publicField(this, "currentCache");
+    __publicField(this, "currentEvents");
+    __publicField(this, "requestParams");
+    __publicField(this, "method");
+    __publicField(this, "params");
+    __publicField(this, "path");
+    __publicField(this, "queue");
+    __publicField(this, "queueName");
+    __publicField(this, "_promise");
+    __publicField(this, "xhr");
+    __publicField(this, "tryRequestCount", 0);
+    __publicField(this, "tryRequestTimeout");
+    this.currentEvents = new EventEmitter2();
+    this._promise = new Promise(() => {
+    });
+    this.queue = new Queue_default(this);
+    this.cacheIndex = "";
+    this.queueName = "";
+    this.method = method;
+    this.headers = __spreadValues(__spreadValues({}, this.headers), params.headers);
+    this.params = __spreadValues(__spreadProps(__spreadValues({}, this.config), {
+      headers: this.headers
+    }), params);
+    this.path = this.params.path;
+    this.requestParams = {
+      method: this.method
+    };
+    this.handleSuccess = this.handleSuccess.bind(this);
+    this.handleAbort = this.handleAbort.bind(this);
+    this.handleFail = this.handleFail.bind(this);
+    this.handleError = this.handleError.bind(this);
+    this.handleComplete = this.handleComplete.bind(this);
+    this.handleProgress = this.handleProgress.bind(this);
+    this.setEmit = this.setEmit.bind(this);
+    this.request = this.request.bind(this);
+    this.httpRequest = this.httpRequest.bind(this);
+    this.tryHttpRequest = this.tryHttpRequest.bind(this);
+    this.initRequest();
+    this.initCache();
+    this.initQueue();
+  }
+  initRequest() {
+    var _a;
+    if (typeof XMLHttpRequest !== "undefined") {
+      this.xhr = new XMLHttpRequest();
+    }
+    if (this.params.clearUndifinedData)
+      this.params.data = this.params.data ? this.cuteUndifinedParams(this.params.data) : this.params.data;
+    if (["GET", "HEAD"].includes(this.method)) {
+      if (this.params.data)
+        this.path = this.params.path + "?" + this.encodeUrlParams(this.params.data);
+      if (this.method === "HEAD") {
+        this.requestParams.withoutResponse = true;
+      }
+    }
+    if (["POST", "PUT", "CONNECT", "PATH"].includes(this.method)) {
+      this.requestParams.body = (_a = this.params.body) != null ? _a : JSON.stringify(this.params.data);
+    }
+    if (["PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE"].includes(this.method)) {
+      this.params.cache = false;
+    }
+  }
+  initCache() {
+    var _a;
+    this.cacheIndex = md5(this.path + JSON.stringify(this.params.data));
+    if (this.params.globalName) {
+      if (this.initData[this.params.globalName]) {
+        const data = this.config.globalDataWithoutDataPrepare ? this.initData[this.params.globalName] : this.dataPrepare(this.initData[this.params.globalName]);
+        this.setCache(this.cacheIndex, data, typeof this.params.cache === "boolean" ? void 0 : this.params.cache);
+        this.params.cache = (_a = this.params.cache) != null ? _a : true;
+        delete this.initData[this.params.globalName];
+      }
+    }
+    if (this.params.cache) {
+      if (typeof this.params.cache === "string") {
+        this.events.addListener("trigger-request-by-cache-" + this.params.cache, this.request);
+      }
+      this._promise = new Promise((resolve) => __async(this, null, function* () {
+        if (this.currentCache = this.getCache(this.cacheIndex)) {
+          resolve(this.currentCache);
+          this.handleSuccess(this.currentCache);
+          this.handleComplete(this.currentCache);
+        }
+      }));
+    } else {
+      this.deleteCache(this.cacheIndex);
+    }
+  }
+  get host() {
+    return this.params.host;
+  }
+  get promise() {
+    return this._promise;
+  }
+  get url() {
+    return this.params.host + this.path;
+  }
+  initQueue() {
+    this.queueName = this.params.queueThrottling ? md5(this.path) : this.cacheIndex;
+  }
+  setEmit(event, data) {
+    this.currentEvents.emit(event, data);
+    this.events.emit(event, {
+      cacheIndex: this.cacheIndex,
+      data
+    });
+  }
+  //Заголовки от 200 до 299
+  handleSuccess(data) {
+    if (typeof this.params.success === "function" && this.xhr)
+      this.params.success(data, this.xhr);
+    if (this.params.cacheUpdate && this.params.data) {
+      this.groupFromArray(this.params.cacheUpdate, (cacheUpdate, params) => {
+        var _a;
+        this.updateCacheGroup(
+          typeof cacheUpdate === "string" ? cacheUpdate : cacheUpdate.group,
+          (_a = this.params.data) != null ? _a : {},
+          typeof cacheUpdate === "string" ? void 0 : cacheUpdate.fieldKey
+        );
+      }, true);
+    }
+    if (this.params.cacheClear && this.params.data) {
+      this.groupFromArray(this.params.cacheClear, (cacheClear) => {
+        this.clearCacheGroup(
+          typeof cacheClear === "string" ? cacheClear : cacheClear.group,
+          this.params.data,
+          typeof cacheClear === "string" ? void 0 : cacheClear.fieldKey
+        );
+      });
+    }
+    this.setEmit("api-request-success", data);
+  }
+  handleAbort(data) {
+    if (typeof this.params.abort === "function") {
+      this.params.abort(data);
+    }
+    this.setEmit("api-request-abort", data);
+  }
+  //Заголовки от 400 до 499
+  handleFail(data) {
+    if (typeof this.params.fail === "function") {
+      this.params.fail(data);
+    }
+    this.setEmit("api-request-fail", data);
+  }
+  //Все остальные
+  handleError(data) {
+    var _a;
+    if (((_a = this.xhr) == null ? void 0 : _a.status) === 0 && this.xhr.readyState === 4) {
+      return;
+    }
+    if (typeof this.params.error === "function") {
+      this.params.error(data);
+    }
+    this.setEmit("api-request-error", data);
+  }
+  handleComplete(data) {
+    if (typeof this.params.complete === "function") {
+      this.params.complete(data);
+    }
+    this.setEmit("api-request-complete", data);
+  }
+  handleProgress(progress) {
+    if (typeof this.params.progress === "function") {
+      this.params.progress(progress);
+    }
+    this.setEmit("api-request-progress", progress);
+  }
+  encodeUrlParams(data, prefix = "") {
+    return Object.entries(data).filter(([_, value]) => value !== void 0 && value !== null).map(([key, value]) => {
+      const encodedKey = prefix ? `${prefix}[${encodeURIComponent(key)}]` : encodeURIComponent(key);
+      if (Array.isArray(value)) {
+        if (value.length === 0) return `${encodedKey}[]=`;
+        return value.map((val) => `${encodedKey}[]=${encodeURIComponent(String(val))}`).join("&");
+      }
+      if (typeof value === "object" && value !== null) {
+        return this.encodeUrlParams(value, encodedKey);
+      }
+      return `${encodedKey}=${encodeURIComponent(String(value))}`;
+    }).filter((str) => str !== "").join("&");
+  }
+  cuteUndifinedParams(data) {
+    if (typeof data !== "object" || data === null) {
+      return data;
+    }
+    for (const key in data) {
+      if (typeof data[key] === "undefined") {
+        delete data[key];
+      }
+    }
+    return data;
+  }
+  tryHttpRequest() {
+    return new Promise((resolve, reject) => {
+      var _a;
+      if (this.params.tryRequest && this.params.tryRequest > this.tryRequestCount) {
+        if (this.tryRequestTimeout) {
+          clearTimeout(this.tryRequestTimeout);
+        }
+        this.tryRequestTimeout = setTimeout(() => {
+          var _a2;
+          (_a2 = this.xhr) == null ? void 0 : _a2.abort();
+          this.httpRequest().then((value) => {
+            resolve(value);
+            this.tryRequestCount = 0;
+          }).catch(reject);
+        }, (_a = this.params.tryRequestDelay) != null ? _a : 1e3);
+        ++this.tryRequestCount;
+      } else {
+        reject();
+      }
+    });
+  }
+  fileRequest() {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
+      if (!this.params.file) return;
+      const data = this.params.file;
+      const chunkSize = this.params.fileSizeChunk ? this.params.fileSizeChunk * 1024 * 1024 : this.params.file.byteLength;
+      const totalChunks = Math.ceil(this.params.file.byteLength / chunkSize);
+      let fileId = this.params.fileIdByServer ? void 0 : `file-${(/* @__PURE__ */ new Date()).getTime()}`;
+      for (let i = 0; i < totalChunks; i++) {
+        try {
+          const start = i * chunkSize;
+          const end = Math.min(start + chunkSize, data.byteLength);
+          const chunk = data.slice(start, end);
+          const headers = __spreadValues({}, this.headers);
+          let body = void 0;
+          if (this.params.fileType === "binary") {
+            const u8 = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+            headers["Content-Type"] = "application/octet-stream";
+            headers["Content-Range"] = `bytes ${start}-${end - 1}/${this.params.file.byteLength}`;
+            headers["X-Chunk-Index"] = String(i);
+            headers["X-Chunk-Total"] = String(totalChunks);
+            if (fileId && (!this.params.fileIdByServer || this.params.fileIdByServer && i > 0)) {
+              headers[typeof this.params.fileIdByServer === "string" ? this.params.fileIdByServer : "X-File-ID"] = fileId;
+            }
+            body = u8;
+          } else {
+            const formData = new FormData();
+            formData.append("file", new Blob([chunk]));
+            if (fileId && (!this.params.fileIdByServer || this.params.fileIdByServer && i > 0)) {
+              formData.append(typeof this.params.fileIdByServer === "string" ? this.params.fileIdByServer : "file_id", fileId);
+            }
+            formData.append("chunk_index", String(i));
+            formData.append("total_chunks", String(totalChunks));
+            if (this.params.data && totalChunks - 1 === i) {
+              for (const key in this.params.data) {
+                formData.append(key, this.params.data[key]);
+              }
+            }
+            delete headers["Content-Type"];
+            body = formData;
+          }
+          delete headers["Accept"];
+          const http = new _Http(this.method, __spreadProps(__spreadValues({}, this.params), {
+            file: void 0,
+            headers,
+            data: void 0,
+            fileSizeChunk: void 0,
+            body,
+            success: totalChunks - 1 > i ? void 0 : (data2) => {
+              resolve(data2);
+              this.handleSuccess(data2);
+            },
+            complete: totalChunks - 1 > i ? void 0 : (e) => {
+              this.handleComplete(e);
+            },
+            progress: (progres) => {
+              const loaded = start + progres.loaded;
+              this.handleProgress({
+                percent: loaded / data.byteLength * 100,
+                total: data.byteLength,
+                loaded
+              });
+            },
+            fail: reject,
+            error: reject
+          }), this);
+          this.xhr = http.xhr;
+          const result = yield http.request(true).promise;
+          if (result == null ? void 0 : result.file_id) {
+            fileId = result == null ? void 0 : result.file_id;
+          }
+        } catch (e) {
+          reject(e);
+          break;
+        }
+      }
+    }));
+  }
+  httpRequest() {
+    return new Promise((resolve, reject) => {
+      var _a;
+      if (typeof this.xhr === "undefined") return;
+      try {
+        this.xhr.open(this.method, this.url, (_a = this.params.requestAsync) != null ? _a : true);
+        if (this.params.timeout) {
+          this.xhr.timeout = this.params.timeout;
+        }
+        for (const header in this.headers) {
+          this.xhr.setRequestHeader(header, this.headers[header]);
+        }
+        if (this.xhr.upload) {
+          this.xhr.upload.onprogress = ({ lengthComputable, loaded, total }) => {
+            if (lengthComputable) {
+              this.handleProgress({
+                percent: loaded / total * 100,
+                total,
+                loaded
+              });
+            }
+          };
+        }
+        this.xhr.onabort = () => {
+          reject({
+            type: "abort",
+            message: "request abort"
+          });
+          this.handleAbort({
+            message: "request abort"
+          });
+        };
+        this.xhr.ontimeout = () => {
+          this.tryHttpRequest().then(resolve).catch(reject);
+        };
+        this.xhr.onerror = (event) => __async(this, null, function* () {
+          yield this.tryHttpRequest().then(resolve).catch(reject);
+          reject({
+            type: "error",
+            message: "request error",
+            event
+          });
+          this.handleError({
+            message: "request error",
+            event
+          });
+        });
+        this.xhr.onreadystatechange = () => {
+          var _a2, _b;
+          if (((_a2 = this.xhr) == null ? void 0 : _a2.readyState) !== XMLHttpRequest.DONE) return;
+          const result = !this.requestParams.withoutResponse && this.isJsonString(this.xhr.responseText) ? this.jsonParse(this.xhr.responseText) : {};
+          if (((_b = this.xhr) == null ? void 0 : _b.status) >= 200 && this.xhr.status <= 299) {
+            if (this.params.cache) {
+              this.setCache(this.cacheIndex, result, typeof this.params.cache === "boolean" ? void 0 : this.params.cache);
+            }
+            resolve(result);
+            this.handleSuccess(result);
+          } else {
+            if (this.xhr.status >= 100 && this.xhr.status <= 500) {
+              reject(result);
+              this.handleFail(result);
+            }
+          }
+          this.handleComplete(result);
+          this.queue.clear(this.queueName);
+        };
+        this.xhr.send(this.requestParams.body);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  streamRequest() {
+    return new Promise((resolve, reject) => {
+      fetch(this.url, {
+        method: this.method,
+        headers: this.headers,
+        body: this.requestParams.body
+      }).then((response) => {
+        this.handleSuccess(response);
+        resolve(response);
+      }).catch((e) => {
+        this.handleFail(e);
+        reject(e);
+      });
+    });
+  }
+  request(force) {
+    if (!force && !this.params.forceRequest && (this.currentCache || this.queue.push(this.queueName))) return this;
+    this._promise = new Promise((resolve, reject) => __async(this, null, function* () {
+      try {
+        let result;
+        if (this.params.stream) {
+          result = yield this.streamRequest();
+        } else if (this.params.file) {
+          result = yield this.fileRequest();
+        } else {
+          result = yield this.httpRequest();
+        }
+        resolve(result);
+      } catch (e) {
+        reject(e);
+      }
+    }));
+    return this;
+  }
+  abort() {
+    var _a;
+    (_a = this.xhr) == null ? void 0 : _a.abort();
+  }
+  addListener(event, callback) {
+    return this.currentEvents.addListener(event, callback);
+  }
+  updateCache(data, fieldKey = "id") {
+    const cache = this.getCacheByIndex(this.cacheIndex);
+    if (cache && cache.group) {
+      this.updateCacheGroup(cache.group, data, fieldKey);
+    }
+  }
+  clearCache(data, fieldKey = "id") {
+    if (data) {
+      const cache = this.getCacheByIndex(this.cacheIndex);
+      if (cache && cache.group) {
+        this.clearCacheGroup(cache.group, data, fieldKey);
+      }
+    } else {
+      this.deleteCache(this.cacheIndex);
+    }
+  }
+};
+var Http_default = Http;
+
+// src/index.ts
+var _API = class _API extends Core_default {
+  constructor(config) {
+    super();
+    __publicField(this, "_user");
+    __publicField(this, "token");
+    __publicField(this, "csrfToken");
+    this.headers = __spreadValues({
+      "Accept": "application/json",
+      "Content-Type": "application/json"
+    }, config.headers);
+    this.setConfig(config);
+    this._user = {};
+    this.setToken = this.setToken.bind(this);
+    this.setCSRFToken = this.setCSRFToken.bind(this);
+    this.setLogin = this.setLogin.bind(this);
+    this.setUser = this.setUser.bind(this);
+    this.updateUser = this.updateUser.bind(this);
+    this.logout = this.logout.bind(this);
+    this.getToken = this.getToken.bind(this);
+    this.getCSRFToken = this.getCSRFToken.bind(this);
+    this.http = this.http.bind(this);
+    this.get = this.get.bind(this);
+    this.head = this.head.bind(this);
+    this.post = this.post.bind(this);
+    this.put = this.put.bind(this);
+    this.patch = this.patch.bind(this);
+    this.delete = this.delete.bind(this);
+    this.options = this.options.bind(this);
+    this.connect = this.connect.bind(this);
+    this.trace = this.trace.bind(this);
+    this.getUid = this.getUid.bind(this);
+    this.getUser = this.getUser.bind(this);
+    this.addListener = this.addListener.bind(this);
+    this.getConfig = this.getConfig.bind(this);
+  }
+  http(method, params) {
+    const http = new Http_default(method, params, this);
+    if (this.token) http.setHeader("Authorization", `Bearer ${this.token}`);
+    if (this.csrfToken) http.setHeader("X-CSRF-TOKEN", this.csrfToken);
+    return http;
+  }
+  get(params) {
+    return this.http("GET", params).request();
+  }
+  head(params) {
+    return this.http("HEAD", params).request();
+  }
+  post(params) {
+    return this.http("POST", params).request();
+  }
+  put(params) {
+    return this.http("PUT", params).request();
+  }
+  patch(params) {
+    return this.http("PATCH", params).request();
+  }
+  delete(params) {
+    return this.http("DELETE", params).request();
+  }
+  options(params) {
+    return this.http("OPTIONS", params).request();
+  }
+  connect(params) {
+    return this.http("CONNECT", params).request();
+  }
+  trace(params) {
+    return this.http("TRACE", params).request();
+  }
+  addListener(event, callback) {
+    return this.events.addListener(event, callback);
+  }
+  setToken(token) {
+    this.token = token;
+    this.events.emit("token-update", token);
+  }
+  setCSRFToken(csrfToken) {
+    this.csrfToken = csrfToken;
+    this.events.emit("csrf-token-update", csrfToken);
+  }
+  getConfig() {
+    return this.config;
+  }
+  getToken() {
+    return this.token;
+  }
+  getCSRFToken() {
+    return this.csrfToken;
+  }
+  getUid() {
+    return typeof this._user === "object" && "id" in this._user ? Number(this._user.id) : 0;
+  }
+  getUser() {
+    return this._user;
+  }
+  get uid() {
+    return this.getUid();
+  }
+  get user() {
+    return this.getUser();
+  }
+  get host() {
+    return this.config.host;
+  }
+  setLogin(user, token = "") {
+    this.setUser(user);
+    this.setToken(token);
+    this.events.emit("login", {
+      user,
+      token
+    });
+  }
+  setUser(user) {
+    this._user = user;
+    this.events.emit("user-set", user);
+  }
+  updateUser(user) {
+    const updatedUser = __spreadValues(__spreadValues({}, this.user), user);
+    this.setUser(updatedUser);
+    this.events.emit("user-update", updatedUser);
+  }
+  logout() {
+    return __async(this, null, function* () {
+      const user = this.user;
+      this.setUser({});
+      this.setToken("");
+      this.events.emit("logout", user);
+    });
+  }
+};
+__publicField(_API, "instance", new _API({
+  host: ""
+}));
+__publicField(_API, "http", _API.instance.http);
+__publicField(_API, "get", _API.instance.get);
+__publicField(_API, "head", _API.instance.head);
+__publicField(_API, "post", _API.instance.post);
+__publicField(_API, "put", _API.instance.put);
+__publicField(_API, "patch", _API.instance.patch);
+__publicField(_API, "delete", _API.instance.delete);
+__publicField(_API, "options", _API.instance.options);
+__publicField(_API, "connect", _API.instance.connect);
+__publicField(_API, "trace", _API.instance.trace);
+__publicField(_API, "setConfig", _API.instance.setConfig);
+__publicField(_API, "setHost", _API.instance.setHost);
+__publicField(_API, "setUser", _API.instance.setUser);
+__publicField(_API, "updateUser", _API.instance.updateUser);
+__publicField(_API, "logout", _API.instance.logout);
+__publicField(_API, "setToken", _API.instance.setToken);
+__publicField(_API, "setLogin", _API.instance.setLogin);
+__publicField(_API, "addListener", _API.instance.addListener);
+__publicField(_API, "setInitData", _API.instance.setInitData);
+__publicField(_API, "setCSRFToken", _API.instance.setCSRFToken);
+__publicField(_API, "getCSRFToken", _API.instance.getCSRFToken);
+__publicField(_API, "triggerByCacheGroup", _API.instance.triggerByCacheGroup);
+__publicField(_API, "clearCacheGroup", _API.instance.clearCacheGroup);
+__publicField(_API, "updateCacheGroup", _API.instance.updateCacheGroup);
+__publicField(_API, "getToken", _API.instance.getToken);
+__publicField(_API, "getUid", _API.instance.getUid);
+__publicField(_API, "getUser", _API.instance.getUser);
+__publicField(_API, "user", _API.instance.user);
+__publicField(_API, "uid", _API.instance.uid);
+/**
+ * @deprecated The method should not be used
+ */
+__publicField(_API, "deleteCacheGroup", _API.instance.clearCacheGroup);
+var API = _API;
+globalThis.apiSetInitData = API.setInitData;
+var index_default = API;
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.mjs.map