wapi-client 0.12.5-beta.1 → 0.12.5-beta.2

package/dist/api/http-client.browser.cjs

@@ -1,9 +1,12 @@
+"use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 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;
@@ -19,6 +22,9 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -31,6 +37,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -53,6 +67,540 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
+// node_modules/fetch-ponyfill/build/fetch-browser.js
+var require_fetch_browser = __commonJS({
+  "node_modules/fetch-ponyfill/build/fetch-browser.js"(exports, module2) {
+    (function(global2) {
+      "use strict";
+      function fetchPonyfill(options) {
+        var Promise2 = options && options.Promise || global2.Promise;
+        var XMLHttpRequest = options && options.XMLHttpRequest || global2.XMLHttpRequest;
+        return function() {
+          var globalThis2 = Object.create(global2, {
+            fetch: {
+              value: void 0,
+              writable: true
+            }
+          });
+          (function(global3, factory) {
+            typeof exports === "object" && typeof module2 !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : factory(global3.WHATWGFetch = {});
+          })(this, function(exports2) {
+            "use strict";
+            var global3 = typeof globalThis2 !== "undefined" && globalThis2 || typeof self !== "undefined" && self || typeof global3 !== "undefined" && global3;
+            var support = {
+              searchParams: "URLSearchParams" in global3,
+              iterable: "Symbol" in global3 && "iterator" in Symbol,
+              blob: "FileReader" in global3 && "Blob" in global3 && function() {
+                try {
+                  new Blob();
+                  return true;
+                } catch (e) {
+                  return false;
+                }
+              }(),
+              formData: "FormData" in global3,
+              arrayBuffer: "ArrayBuffer" in global3
+            };
+            function isDataView(obj) {
+              return obj && DataView.prototype.isPrototypeOf(obj);
+            }
+            if (support.arrayBuffer) {
+              var viewClasses = [
+                "[object Int8Array]",
+                "[object Uint8Array]",
+                "[object Uint8ClampedArray]",
+                "[object Int16Array]",
+                "[object Uint16Array]",
+                "[object Int32Array]",
+                "[object Uint32Array]",
+                "[object Float32Array]",
+                "[object Float64Array]"
+              ];
+              var isArrayBufferView = ArrayBuffer.isView || function(obj) {
+                return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1;
+              };
+            }
+            function normalizeName(name) {
+              if (typeof name !== "string") {
+                name = String(name);
+              }
+              if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "") {
+                throw new TypeError("Invalid character in header field name");
+              }
+              return name.toLowerCase();
+            }
+            function normalizeValue(value) {
+              if (typeof value !== "string") {
+                value = String(value);
+              }
+              return value;
+            }
+            function iteratorFor(items) {
+              var iterator = {
+                next: function() {
+                  var value = items.shift();
+                  return { done: value === void 0, value };
+                }
+              };
+              if (support.iterable) {
+                iterator[Symbol.iterator] = function() {
+                  return iterator;
+                };
+              }
+              return iterator;
+            }
+            function Headers(headers) {
+              this.map = {};
+              if (headers instanceof Headers) {
+                headers.forEach(function(value, name) {
+                  this.append(name, value);
+                }, this);
+              } else if (Array.isArray(headers)) {
+                headers.forEach(function(header) {
+                  this.append(header[0], header[1]);
+                }, this);
+              } else if (headers) {
+                Object.getOwnPropertyNames(headers).forEach(function(name) {
+                  this.append(name, headers[name]);
+                }, this);
+              }
+            }
+            Headers.prototype.append = function(name, value) {
+              name = normalizeName(name);
+              value = normalizeValue(value);
+              var oldValue = this.map[name];
+              this.map[name] = oldValue ? oldValue + ", " + value : value;
+            };
+            Headers.prototype["delete"] = function(name) {
+              delete this.map[normalizeName(name)];
+            };
+            Headers.prototype.get = function(name) {
+              name = normalizeName(name);
+              return this.has(name) ? this.map[name] : null;
+            };
+            Headers.prototype.has = function(name) {
+              return this.map.hasOwnProperty(normalizeName(name));
+            };
+            Headers.prototype.set = function(name, value) {
+              this.map[normalizeName(name)] = normalizeValue(value);
+            };
+            Headers.prototype.forEach = function(callback, thisArg) {
+              for (var name in this.map) {
+                if (this.map.hasOwnProperty(name)) {
+                  callback.call(thisArg, this.map[name], name, this);
+                }
+              }
+            };
+            Headers.prototype.keys = function() {
+              var items = [];
+              this.forEach(function(value, name) {
+                items.push(name);
+              });
+              return iteratorFor(items);
+            };
+            Headers.prototype.values = function() {
+              var items = [];
+              this.forEach(function(value) {
+                items.push(value);
+              });
+              return iteratorFor(items);
+            };
+            Headers.prototype.entries = function() {
+              var items = [];
+              this.forEach(function(value, name) {
+                items.push([name, value]);
+              });
+              return iteratorFor(items);
+            };
+            if (support.iterable) {
+              Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+            }
+            function consumed(body) {
+              if (body.bodyUsed) {
+                return Promise2.reject(new TypeError("Already read"));
+              }
+              body.bodyUsed = true;
+            }
+            function fileReaderReady(reader) {
+              return new Promise2(function(resolve, reject) {
+                reader.onload = function() {
+                  resolve(reader.result);
+                };
+                reader.onerror = function() {
+                  reject(reader.error);
+                };
+              });
+            }
+            function readBlobAsArrayBuffer(blob) {
+              var reader = new FileReader();
+              var promise = fileReaderReady(reader);
+              reader.readAsArrayBuffer(blob);
+              return promise;
+            }
+            function readBlobAsText(blob) {
+              var reader = new FileReader();
+              var promise = fileReaderReady(reader);
+              reader.readAsText(blob);
+              return promise;
+            }
+            function readArrayBufferAsText(buf) {
+              var view = new Uint8Array(buf);
+              var chars = new Array(view.length);
+              for (var i = 0; i < view.length; i++) {
+                chars[i] = String.fromCharCode(view[i]);
+              }
+              return chars.join("");
+            }
+            function bufferClone(buf) {
+              if (buf.slice) {
+                return buf.slice(0);
+              } else {
+                var view = new Uint8Array(buf.byteLength);
+                view.set(new Uint8Array(buf));
+                return view.buffer;
+              }
+            }
+            function Body() {
+              this.bodyUsed = false;
+              this._initBody = function(body) {
+                this.bodyUsed = this.bodyUsed;
+                this._bodyInit = body;
+                if (!body) {
+                  this._bodyText = "";
+                } else if (typeof body === "string") {
+                  this._bodyText = body;
+                } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+                  this._bodyBlob = body;
+                } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+                  this._bodyFormData = body;
+                } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+                  this._bodyText = body.toString();
+                } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+                  this._bodyArrayBuffer = bufferClone(body.buffer);
+                  this._bodyInit = new Blob([this._bodyArrayBuffer]);
+                } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+                  this._bodyArrayBuffer = bufferClone(body);
+                } else {
+                  this._bodyText = body = Object.prototype.toString.call(body);
+                }
+                if (!this.headers.get("content-type")) {
+                  if (typeof body === "string") {
+                    this.headers.set("content-type", "text/plain;charset=UTF-8");
+                  } else if (this._bodyBlob && this._bodyBlob.type) {
+                    this.headers.set("content-type", this._bodyBlob.type);
+                  } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+                    this.headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+                  }
+                }
+              };
+              if (support.blob) {
+                this.blob = function() {
+                  var rejected = consumed(this);
+                  if (rejected) {
+                    return rejected;
+                  }
+                  if (this._bodyBlob) {
+                    return Promise2.resolve(this._bodyBlob);
+                  } else if (this._bodyArrayBuffer) {
+                    return Promise2.resolve(new Blob([this._bodyArrayBuffer]));
+                  } else if (this._bodyFormData) {
+                    throw new Error("could not read FormData body as blob");
+                  } else {
+                    return Promise2.resolve(new Blob([this._bodyText]));
+                  }
+                };
+                this.arrayBuffer = function() {
+                  if (this._bodyArrayBuffer) {
+                    var isConsumed = consumed(this);
+                    if (isConsumed) {
+                      return isConsumed;
+                    }
+                    if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+                      return Promise2.resolve(
+                        this._bodyArrayBuffer.buffer.slice(
+                          this._bodyArrayBuffer.byteOffset,
+                          this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
+                        )
+                      );
+                    } else {
+                      return Promise2.resolve(this._bodyArrayBuffer);
+                    }
+                  } else {
+                    return this.blob().then(readBlobAsArrayBuffer);
+                  }
+                };
+              }
+              this.text = function() {
+                var rejected = consumed(this);
+                if (rejected) {
+                  return rejected;
+                }
+                if (this._bodyBlob) {
+                  return readBlobAsText(this._bodyBlob);
+                } else if (this._bodyArrayBuffer) {
+                  return Promise2.resolve(readArrayBufferAsText(this._bodyArrayBuffer));
+                } else if (this._bodyFormData) {
+                  throw new Error("could not read FormData body as text");
+                } else {
+                  return Promise2.resolve(this._bodyText);
+                }
+              };
+              if (support.formData) {
+                this.formData = function() {
+                  return this.text().then(decode);
+                };
+              }
+              this.json = function() {
+                return this.text().then(JSON.parse);
+              };
+              return this;
+            }
+            var methods = ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"];
+            function normalizeMethod(method) {
+              var upcased = method.toUpperCase();
+              return methods.indexOf(upcased) > -1 ? upcased : method;
+            }
+            function Request(input, options2) {
+              if (!(this instanceof Request)) {
+                throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');
+              }
+              options2 = options2 || {};
+              var body = options2.body;
+              if (input instanceof Request) {
+                if (input.bodyUsed) {
+                  throw new TypeError("Already read");
+                }
+                this.url = input.url;
+                this.credentials = input.credentials;
+                if (!options2.headers) {
+                  this.headers = new Headers(input.headers);
+                }
+                this.method = input.method;
+                this.mode = input.mode;
+                this.signal = input.signal;
+                if (!body && input._bodyInit != null) {
+                  body = input._bodyInit;
+                  input.bodyUsed = true;
+                }
+              } else {
+                this.url = String(input);
+              }
+              this.credentials = options2.credentials || this.credentials || "same-origin";
+              if (options2.headers || !this.headers) {
+                this.headers = new Headers(options2.headers);
+              }
+              this.method = normalizeMethod(options2.method || this.method || "GET");
+              this.mode = options2.mode || this.mode || null;
+              this.signal = options2.signal || this.signal;
+              this.referrer = null;
+              if ((this.method === "GET" || this.method === "HEAD") && body) {
+                throw new TypeError("Body not allowed for GET or HEAD requests");
+              }
+              this._initBody(body);
+              if (this.method === "GET" || this.method === "HEAD") {
+                if (options2.cache === "no-store" || options2.cache === "no-cache") {
+                  var reParamSearch = /([?&])_=[^&]*/;
+                  if (reParamSearch.test(this.url)) {
+                    this.url = this.url.replace(reParamSearch, "$1_=" + (/* @__PURE__ */ new Date()).getTime());
+                  } else {
+                    var reQueryString = /\?/;
+                    this.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (/* @__PURE__ */ new Date()).getTime();
+                  }
+                }
+              }
+            }
+            Request.prototype.clone = function() {
+              return new Request(this, { body: this._bodyInit });
+            };
+            function decode(body) {
+              var form = new FormData();
+              body.trim().split("&").forEach(function(bytes) {
+                if (bytes) {
+                  var split = bytes.split("=");
+                  var name = split.shift().replace(/\+/g, " ");
+                  var value = split.join("=").replace(/\+/g, " ");
+                  form.append(decodeURIComponent(name), decodeURIComponent(value));
+                }
+              });
+              return form;
+            }
+            function parseHeaders(rawHeaders) {
+              var headers = new Headers();
+              var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
+              preProcessedHeaders.split("\r").map(function(header) {
+                return header.indexOf("\n") === 0 ? header.substr(1, header.length) : header;
+              }).forEach(function(line) {
+                var parts = line.split(":");
+                var key = parts.shift().trim();
+                if (key) {
+                  var value = parts.join(":").trim();
+                  headers.append(key, value);
+                }
+              });
+              return headers;
+            }
+            Body.call(Request.prototype);
+            function Response(bodyInit, options2) {
+              if (!(this instanceof Response)) {
+                throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');
+              }
+              if (!options2) {
+                options2 = {};
+              }
+              this.type = "default";
+              this.status = options2.status === void 0 ? 200 : options2.status;
+              this.ok = this.status >= 200 && this.status < 300;
+              this.statusText = "statusText" in options2 ? options2.statusText : "";
+              this.headers = new Headers(options2.headers);
+              this.url = options2.url || "";
+              this._initBody(bodyInit);
+            }
+            Body.call(Response.prototype);
+            Response.prototype.clone = function() {
+              return new Response(this._bodyInit, {
+                status: this.status,
+                statusText: this.statusText,
+                headers: new Headers(this.headers),
+                url: this.url
+              });
+            };
+            Response.error = function() {
+              var response = new Response(null, { status: 0, statusText: "" });
+              response.type = "error";
+              return response;
+            };
+            var redirectStatuses = [301, 302, 303, 307, 308];
+            Response.redirect = function(url, status) {
+              if (redirectStatuses.indexOf(status) === -1) {
+                throw new RangeError("Invalid status code");
+              }
+              return new Response(null, { status, headers: { location: url } });
+            };
+            exports2.DOMException = global3.DOMException;
+            try {
+              new exports2.DOMException();
+            } catch (err) {
+              exports2.DOMException = function(message, name) {
+                this.message = message;
+                this.name = name;
+                var error = Error(message);
+                this.stack = error.stack;
+              };
+              exports2.DOMException.prototype = Object.create(Error.prototype);
+              exports2.DOMException.prototype.constructor = exports2.DOMException;
+            }
+            function fetch2(input, init) {
+              return new Promise2(function(resolve, reject) {
+                var request = new Request(input, init);
+                if (request.signal && request.signal.aborted) {
+                  return reject(new exports2.DOMException("Aborted", "AbortError"));
+                }
+                var xhr = new XMLHttpRequest();
+                function abortXhr() {
+                  xhr.abort();
+                }
+                xhr.onload = function() {
+                  var options2 = {
+                    status: xhr.status,
+                    statusText: xhr.statusText,
+                    headers: parseHeaders(xhr.getAllResponseHeaders() || "")
+                  };
+                  options2.url = "responseURL" in xhr ? xhr.responseURL : options2.headers.get("X-Request-URL");
+                  var body = "response" in xhr ? xhr.response : xhr.responseText;
+                  setTimeout(function() {
+                    resolve(new Response(body, options2));
+                  }, 0);
+                };
+                xhr.onerror = function() {
+                  setTimeout(function() {
+                    reject(new TypeError("Network request failed"));
+                  }, 0);
+                };
+                xhr.ontimeout = function() {
+                  setTimeout(function() {
+                    reject(new TypeError("Network request failed"));
+                  }, 0);
+                };
+                xhr.onabort = function() {
+                  setTimeout(function() {
+                    reject(new exports2.DOMException("Aborted", "AbortError"));
+                  }, 0);
+                };
+                function fixUrl(url) {
+                  try {
+                    return url === "" && global3.location.href ? global3.location.href : url;
+                  } catch (e) {
+                    return url;
+                  }
+                }
+                xhr.open(request.method, fixUrl(request.url), true);
+                if (request.credentials === "include") {
+                  xhr.withCredentials = true;
+                } else if (request.credentials === "omit") {
+                  xhr.withCredentials = false;
+                }
+                if ("responseType" in xhr) {
+                  if (support.blob) {
+                    xhr.responseType = "blob";
+                  } else if (support.arrayBuffer && request.headers.get("Content-Type") && request.headers.get("Content-Type").indexOf("application/octet-stream") !== -1) {
+                    xhr.responseType = "arraybuffer";
+                  }
+                }
+                if (init && typeof init.headers === "object" && !(init.headers instanceof Headers)) {
+                  Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+                    xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+                  });
+                } else {
+                  request.headers.forEach(function(value, name) {
+                    xhr.setRequestHeader(name, value);
+                  });
+                }
+                if (request.signal) {
+                  request.signal.addEventListener("abort", abortXhr);
+                  xhr.onreadystatechange = function() {
+                    if (xhr.readyState === 4) {
+                      request.signal.removeEventListener("abort", abortXhr);
+                    }
+                  };
+                }
+                xhr.send(typeof request._bodyInit === "undefined" ? null : request._bodyInit);
+              });
+            }
+            fetch2.polyfill = true;
+            if (!global3.fetch) {
+              global3.fetch = fetch2;
+              global3.Headers = Headers;
+              global3.Request = Request;
+              global3.Response = Response;
+            }
+            exports2.Headers = Headers;
+            exports2.Request = Request;
+            exports2.Response = Response;
+            exports2.fetch = fetch2;
+            Object.defineProperty(exports2, "__esModule", { value: true });
+          });
+          return {
+            fetch: globalThis2.fetch,
+            Headers: globalThis2.Headers,
+            Request: globalThis2.Request,
+            Response: globalThis2.Response,
+            DOMException: globalThis2.DOMException
+          };
+        }();
+      }
+      if (typeof define === "function" && define.amd) {
+        define(function() {
+          return fetchPonyfill;
+        });
+      } else if (typeof exports === "object") {
+        module2.exports = fetchPonyfill;
+      } else {
+        global2.fetchPonyfill = fetchPonyfill;
+      }
+    })(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : exports);
+  }
+});
+
 // src/api/http-client.ts
 var http_client_exports = {};
 __export(http_client_exports, {
@@ -60,13 +608,14 @@ __export(http_client_exports, {
   createHttpClient: () => createHttpClient
 });
 module.exports = __toCommonJS(http_client_exports);
-var import_fetch = require('../lib/isomorphic/web/fetch.cjs');
+var import_fetch_ponyfill = __toESM(require_fetch_browser(), 1);
 var import_debug = require('../lib/debug.cjs');
 var import_jsonrpc = require('./jsonrpc/jsonrpc.enums.cjs');
 var import_base_client = require('./base-client.cjs');
-var import__ = require('../index.cjs');
+var import_wapi_client = require('../wapi-client.cjs');
 var import_errors = require('../lib/errors.cjs');
 var import_utils = require('../lib/utils.cjs');
+var { fetch } = (0, import_fetch_ponyfill.default)();
 function createHttpClient(opts, config) {
   const initialConnection = createConnection(opts, {
     timeout: config == null ? void 0 : config.connectingTimeout,
@@ -91,7 +640,7 @@ function createConnection(opts, connectionConfig) {
   function send(body, jwt) {
     return __async(this, null, function* () {
       const jsonBody = JSON.parse(body);
-      const res = yield (0, import_fetch.fetch)(`${url}/api`, {
+      const res = yield fetch(`${url}/api`, {
         keepalive: true,
         method: "POST",
         headers: __spreadValues({
@@ -122,7 +671,7 @@ function createConnection(opts, connectionConfig) {
         })
       );
     }, connectionConfig.timeout) : void 0;
-    (0, import_fetch.fetch)(`${url}/api`, {
+    fetch(`${url}/api`, {
       method: "POST",
       headers: __spreadValues({
         Authorization: `Bearer ${opts.jwt}`,
@@ -156,7 +705,7 @@ var HttpClient = class extends import_base_client.BaseClient {
   // private _connectionConfig: ConnectionConfig | undefined;
   constructor(connection, opts) {
     var _a;
-    super(connection, import__.WapiClientType.https, connection.$connect);
+    super(connection, import_wapi_client.WapiClientType.https, connection.$connect);
     this.host = opts.host;
     this.jwt = opts.jwt;
     (_a = this.$connect) == null ? void 0 : _a.then(() => {