@kohost/api-client 3.4.6 → 3.6.0

package/dist/esm/defs.js

@@ -735,6 +735,26 @@ var require_axios = __commonJS({
     }, "toJSONObject");
     var isAsyncFn = kindOfTest("AsyncFunction");
     var isThenable = /* @__PURE__ */ __name((thing) => thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch), "isThenable");
+    var _setImmediate = ((setImmediateSupported, postMessageSupported) => {
+      if (setImmediateSupported) {
+        return setImmediate;
+      }
+      return postMessageSupported ? ((token, callbacks) => {
+        _global.addEventListener("message", ({ source, data }) => {
+          if (source === _global && data === token) {
+            callbacks.length && callbacks.shift()();
+          }
+        }, false);
+        return (cb) => {
+          callbacks.push(cb);
+          _global.postMessage(token, "*");
+        };
+      })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
+    })(
+      typeof setImmediate === "function",
+      isFunction(_global.postMessage)
+    );
+    var asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process !== "undefined" && process.nextTick || _setImmediate;
     var utils$1 = {
       isArray,
       isArrayBuffer,
@@ -791,7 +811,9 @@ var require_axios = __commonJS({
       isSpecCompliantForm,
       toJSONObject,
       isAsyncFn,
-      isThenable
+      isThenable,
+      setImmediate: _setImmediate,
+      asap
     };
     function AxiosError(message, code, config, request, response) {
       Error.call(this);
@@ -805,7 +827,10 @@ var require_axios = __commonJS({
       code && (this.code = code);
       config && (this.config = config);
       request && (this.request = request);
-      response && (this.response = response);
+      if (response) {
+        this.response = response;
+        this.status = response.status ? response.status : null;
+      }
     }
     __name(AxiosError, "AxiosError");
     utils$1.inherits(AxiosError, Error, {
@@ -825,7 +850,7 @@ var require_axios = __commonJS({
           // Axios
           config: utils$1.toJSONObject(this.config),
           code: this.code,
-          status: this.response && this.response.status ? this.response.status : null
+          status: this.status
         };
       }, "toJSON")
     });
@@ -1122,9 +1147,8 @@ var require_axios = __commonJS({
       protocols: ["http", "https", "file", "blob", "url", "data"]
     };
     var hasBrowserEnv = typeof window !== "undefined" && typeof document !== "undefined";
-    var hasStandardBrowserEnv = ((product) => {
-      return hasBrowserEnv && ["ReactNative", "NativeScript", "NS"].indexOf(product) < 0;
-    })(typeof navigator !== "undefined" && navigator.product);
+    var _navigator = typeof navigator === "object" && navigator || void 0;
+    var hasStandardBrowserEnv = hasBrowserEnv && (!_navigator || ["ReactNative", "NativeScript", "NS"].indexOf(_navigator.product) < 0);
     var hasStandardBrowserWebWorkerEnv = (() => {
       return typeof WorkerGlobalScope !== "undefined" && // eslint-disable-next-line no-undef
       self instanceof WorkerGlobalScope && typeof self.importScripts === "function";
@@ -1135,6 +1159,7 @@ var require_axios = __commonJS({
       hasBrowserEnv,
       hasStandardBrowserWebWorkerEnv,
       hasStandardBrowserEnv,
+      navigator: _navigator,
       origin
     });
     var platform = {
@@ -1669,27 +1694,35 @@ var require_axios = __commonJS({
     __name(speedometer, "speedometer");
     function throttle(fn, freq) {
       let timestamp = 0;
-      const threshold = 1e3 / freq;
-      let timer = null;
-      return /* @__PURE__ */ __name(function throttled() {
-        const force = this === true;
+      let threshold = 1e3 / freq;
+      let lastArgs;
+      let timer;
+      const invoke = /* @__PURE__ */ __name((args, now = Date.now()) => {
+        timestamp = now;
+        lastArgs = null;
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        fn.apply(null, args);
+      }, "invoke");
+      const throttled = /* @__PURE__ */ __name((...args) => {
         const now = Date.now();
-        if (force || now - timestamp > threshold) {
-          if (timer) {
-            clearTimeout(timer);
-            timer = null;
+        const passed = now - timestamp;
+        if (passed >= threshold) {
+          invoke(args, now);
+        } else {
+          lastArgs = args;
+          if (!timer) {
+            timer = setTimeout(() => {
+              timer = null;
+              invoke(lastArgs);
+            }, threshold - passed);
           }
-          timestamp = now;
-          return fn.apply(null, arguments);
-        }
-        if (!timer) {
-          timer = setTimeout(() => {
-            timer = null;
-            timestamp = Date.now();
-            return fn.apply(null, arguments);
-          }, threshold - (now - timestamp));
         }
       }, "throttled");
+      const flush = /* @__PURE__ */ __name(() => lastArgs && invoke(lastArgs), "flush");
+      return [throttled, flush];
     }
     __name(throttle, "throttle");
     var progressEventReducer = /* @__PURE__ */ __name((listener, isDownloadStream, freq = 3) => {
@@ -1710,17 +1743,26 @@ var require_axios = __commonJS({
           rate: rate ? rate : void 0,
           estimated: rate && total && inRange ? (total - loaded) / rate : void 0,
           event: e,
-          lengthComputable: total != null
+          lengthComputable: total != null,
+          [isDownloadStream ? "download" : "upload"]: true
         };
-        data[isDownloadStream ? "download" : "upload"] = true;
         listener(data);
       }, freq);
     }, "progressEventReducer");
+    var progressEventDecorator = /* @__PURE__ */ __name((total, throttled) => {
+      const lengthComputable = total != null;
+      return [(loaded) => throttled[0]({
+        lengthComputable,
+        total,
+        loaded
+      }), throttled[1]];
+    }, "progressEventDecorator");
+    var asyncDecorator = /* @__PURE__ */ __name((fn) => (...args) => utils$1.asap(() => fn(...args)), "asyncDecorator");
     var isURLSameOrigin = platform.hasStandardBrowserEnv ? (
       // Standard browser envs have full support of the APIs needed to test
       // whether the request URL is of the same origin as current location.
       (/* @__PURE__ */ __name(function standardBrowserEnv() {
-        const msie = /(msie|trident)/i.test(navigator.userAgent);
+        const msie = platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent);
         const urlParsingNode = document.createElement("a");
         let originURL;
         function resolveURL(url) {
@@ -1923,15 +1965,15 @@ var require_axios = __commonJS({
         const _config = resolveConfig(config);
         let requestData = _config.data;
         const requestHeaders = AxiosHeaders$1.from(_config.headers).normalize();
-        let { responseType } = _config;
+        let { responseType, onUploadProgress, onDownloadProgress } = _config;
         let onCanceled;
+        let uploadThrottled, downloadThrottled;
+        let flushUpload, flushDownload;
         function done() {
-          if (_config.cancelToken) {
-            _config.cancelToken.unsubscribe(onCanceled);
-          }
-          if (_config.signal) {
-            _config.signal.removeEventListener("abort", onCanceled);
-          }
+          flushUpload && flushUpload();
+          flushDownload && flushDownload();
+          _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
+          _config.signal && _config.signal.removeEventListener("abort", onCanceled);
         }
         __name(done, "done");
         let request = new XMLHttpRequest();
@@ -1980,11 +2022,11 @@ var require_axios = __commonJS({
           if (!request) {
             return;
           }
-          reject(new AxiosError("Request aborted", AxiosError.ECONNABORTED, _config, request));
+          reject(new AxiosError("Request aborted", AxiosError.ECONNABORTED, config, request));
           request = null;
         }, "handleAbort");
         request.onerror = /* @__PURE__ */ __name(function handleError() {
-          reject(new AxiosError("Network Error", AxiosError.ERR_NETWORK, _config, request));
+          reject(new AxiosError("Network Error", AxiosError.ERR_NETWORK, config, request));
           request = null;
         }, "handleError");
         request.ontimeout = /* @__PURE__ */ __name(function handleTimeout() {
@@ -1996,7 +2038,7 @@ var require_axios = __commonJS({
           reject(new AxiosError(
             timeoutErrorMessage,
             transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
-            _config,
+            config,
             request
           ));
           request = null;
@@ -2013,11 +2055,14 @@ var require_axios = __commonJS({
         if (responseType && responseType !== "json") {
           request.responseType = _config.responseType;
         }
-        if (typeof _config.onDownloadProgress === "function") {
-          request.addEventListener("progress", progressEventReducer(_config.onDownloadProgress, true));
+        if (onDownloadProgress) {
+          [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);
+          request.addEventListener("progress", downloadThrottled);
         }
-        if (typeof _config.onUploadProgress === "function" && request.upload) {
-          request.upload.addEventListener("progress", progressEventReducer(_config.onUploadProgress));
+        if (onUploadProgress && request.upload) {
+          [uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress);
+          request.upload.addEventListener("progress", uploadThrottled);
+          request.upload.addEventListener("loadend", flushUpload);
         }
         if (_config.cancelToken || _config.signal) {
           onCanceled = /* @__PURE__ */ __name((cancel) => {
@@ -2096,39 +2141,52 @@ var require_axios = __commonJS({
     var trackStream = /* @__PURE__ */ __name((stream, chunkSize, onProgress, onFinish, encode2) => {
       const iterator = readBytes(stream, chunkSize, encode2);
       let bytes = 0;
+      let done;
+      let _onFinish = /* @__PURE__ */ __name((e) => {
+        if (!done) {
+          done = true;
+          onFinish && onFinish(e);
+        }
+      }, "_onFinish");
       return new ReadableStream({
-        type: "bytes",
         async pull(controller) {
-          const { done, value } = await iterator.next();
-          if (done) {
-            controller.close();
-            onFinish();
-            return;
+          try {
+            const { done: done2, value } = await iterator.next();
+            if (done2) {
+              _onFinish();
+              controller.close();
+              return;
+            }
+            let len = value.byteLength;
+            if (onProgress) {
+              let loadedBytes = bytes += len;
+              onProgress(loadedBytes);
+            }
+            controller.enqueue(new Uint8Array(value));
+          } catch (err) {
+            _onFinish(err);
+            throw err;
           }
-          let len = value.byteLength;
-          onProgress && onProgress(bytes += len);
-          controller.enqueue(new Uint8Array(value));
         },
         cancel(reason) {
-          onFinish(reason);
+          _onFinish(reason);
           return iterator.return();
         }
       }, {
         highWaterMark: 2
       });
     }, "trackStream");
-    var fetchProgressDecorator = /* @__PURE__ */ __name((total, fn) => {
-      const lengthComputable = total != null;
-      return (loaded) => setTimeout(() => fn({
-        lengthComputable,
-        total,
-        loaded
-      }));
-    }, "fetchProgressDecorator");
     var isFetchSupported = typeof fetch === "function" && typeof Request === "function" && typeof Response === "function";
     var isReadableStreamSupported = isFetchSupported && typeof ReadableStream === "function";
     var encodeText = isFetchSupported && (typeof TextEncoder === "function" ? /* @__PURE__ */ ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) : async (str) => new Uint8Array(await new Response(str).arrayBuffer()));
-    var supportsRequestStream = isReadableStreamSupported && (() => {
+    var test = /* @__PURE__ */ __name((fn, ...args) => {
+      try {
+        return !!fn(...args);
+      } catch (e) {
+        return false;
+      }
+    }, "test");
+    var supportsRequestStream = isReadableStreamSupported && test(() => {
       let duplexAccessed = false;
       const hasContentType = new Request(platform.origin, {
         body: new ReadableStream(),
@@ -2139,14 +2197,9 @@ var require_axios = __commonJS({
         }
       }).headers.has("Content-Type");
       return duplexAccessed && !hasContentType;
-    })();
+    });
     var DEFAULT_CHUNK_SIZE = 64 * 1024;
-    var supportsResponseStream = isReadableStreamSupported && !!(() => {
-      try {
-        return utils$1.isReadableStream(new Response("").body);
-      } catch (err) {
-      }
-    })();
+    var supportsResponseStream = isReadableStreamSupported && test(() => utils$1.isReadableStream(new Response("").body));
     var resolvers = {
       stream: supportsResponseStream && ((res) => res.body)
     };
@@ -2167,7 +2220,7 @@ var require_axios = __commonJS({
       if (utils$1.isSpecCompliantForm(body)) {
         return (await new Request(body).arrayBuffer()).byteLength;
       }
-      if (utils$1.isArrayBufferView(body)) {
+      if (utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body)) {
         return body.byteLength;
       }
       if (utils$1.isURLSearchParams(body)) {
@@ -2218,15 +2271,17 @@ var require_axios = __commonJS({
             headers.setContentType(contentTypeHeader);
           }
           if (_request.body) {
-            data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, fetchProgressDecorator(
+            const [onProgress, flush] = progressEventDecorator(
               requestContentLength,
-              progressEventReducer(onUploadProgress)
-            ), null, encodeText);
+              progressEventReducer(asyncDecorator(onUploadProgress))
+            );
+            data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush, encodeText);
           }
         }
         if (!utils$1.isString(withCredentials)) {
-          withCredentials = withCredentials ? "cors" : "omit";
+          withCredentials = withCredentials ? "include" : "omit";
         }
+        const isCredentialsSupported = "credentials" in Request.prototype;
         request = new Request(url, {
           ...fetchOptions,
           signal: composedSignal,
@@ -2234,7 +2289,7 @@ var require_axios = __commonJS({
           headers: headers.normalize().toJSON(),
           body: data,
           duplex: "half",
-          withCredentials
+          credentials: isCredentialsSupported ? withCredentials : void 0
         });
         let response = await fetch(request);
         const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
@@ -2244,11 +2299,15 @@ var require_axios = __commonJS({
             options[prop] = response[prop];
           });
           const responseContentLength = utils$1.toFiniteNumber(response.headers.get("content-length"));
+          const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
+            responseContentLength,
+            progressEventReducer(asyncDecorator(onDownloadProgress), true)
+          ) || [];
           response = new Response(
-            trackStream(response.body, DEFAULT_CHUNK_SIZE, onDownloadProgress && fetchProgressDecorator(
-              responseContentLength,
-              progressEventReducer(onDownloadProgress, true)
-            ), isStreamResponse && onFinish, encodeText),
+            trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+              flush && flush();
+              isStreamResponse && onFinish();
+            }, encodeText),
             options
           );
         }
@@ -2376,7 +2435,7 @@ var require_axios = __commonJS({
       }, "onAdapterRejection"));
     }
     __name(dispatchRequest, "dispatchRequest");
-    var VERSION = "1.7.2";
+    var VERSION = "1.7.5";
     var validators$1 = {};
     ["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => {
       validators$1[type] = /* @__PURE__ */ __name(function validator2(thing) {