wapi-client 0.7.2 → 0.8.2

package/dist/lib/stream-promise.js

@@ -0,0 +1,187 @@
+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));
+
+// src/lib/stream-promise.ts
+import { ERROR_TYPES, getError, StreamError } from "./errors";
+import { JSONRPC } from "../api/jsonrpc/jsonrpc.enums";
+import { ReadStream } from "./isomorphic/node/streams";
+var StreamPromise = class {
+  constructor(makeRequest) {
+    this.streamObject = new ReadStream({
+      objectMode: true
+    });
+    this.outStreamObject = new ReadStream({
+      objectMode: true
+    });
+    this.started = false;
+    this.makeRequest = makeRequest;
+  }
+  start(asMode) {
+    if (this.mode && this.mode !== asMode) {
+      throw new Error("Already in use as " + this.mode);
+    }
+    if (this.started) {
+      return;
+    }
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+    this.started = true;
+    this.mode = asMode;
+    if (this.makeRequest === void 0) {
+      this.streamObject.push(null);
+      this.resolve(void 0);
+      return;
+    }
+    this.makeRequest(this.streamObject).catch(this.reject);
+    const internalArr = [];
+    if (this.mode === "stream") {
+      this.streamObject.on(
+        "data",
+        (chunk) => {
+          if (!chunk) {
+            this.outStreamObject.push(chunk);
+          }
+          if (chunk.error) {
+            const error = getError(chunk.error);
+            this.outStreamObject.destroy(error);
+            return this.streamObject.destroy(error);
+          }
+          if (!chunk.prop) {
+            internalArr.push(chunk);
+            return;
+          }
+          if (chunk.dataArr) {
+            const base = __spreadValues({}, chunk);
+            delete base.dataArr;
+            chunk.dataArr.forEach((data) => {
+              this.outStreamObject.push(__spreadProps(__spreadValues({}, base), {
+                data
+              }));
+            });
+            return;
+          }
+          this.outStreamObject.push(chunk);
+        }
+      ).on("end", () => {
+        const lastMessage = internalArr.pop();
+        if (!lastMessage) {
+          return;
+        }
+        const result = lastMessage.result;
+        Object.keys(result).forEach((prop) => {
+          if (!Array.isArray(result[prop])) {
+            return;
+          }
+          result[prop].forEach((data) => {
+            this.outStreamObject.push({
+              type: JSONRPC.streamChunk,
+              prop,
+              data
+            });
+          });
+          result[prop] = [];
+        });
+        this.outStreamObject.push(lastMessage);
+        this.outStreamObject.push(null);
+      }).on("error", (err) => {
+        this.outStreamObject.destroy(err);
+      });
+      return;
+    }
+    if (this.mode === "promise") {
+      const internalMap = /* @__PURE__ */ new Map();
+      this.streamObject.on(
+        "data",
+        (chunk) => {
+          var _a;
+          if (chunk === void 0) {
+            return;
+          }
+          if (chunk.error) {
+            const error = getError(chunk.error);
+            return this.streamObject.destroy(error);
+          }
+          if (!chunk.prop) {
+            internalArr.push(chunk);
+            return;
+          }
+          const arr = (_a = internalMap.get(chunk.prop)) != null ? _a : [];
+          if (chunk.dataArr) {
+            arr.push(...chunk.dataArr);
+          } else {
+            arr.push(chunk.data);
+          }
+          internalMap.set(chunk.prop, arr);
+        }
+      ).on("end", () => {
+        const lastMessage = internalArr.pop();
+        if (!lastMessage) {
+          return;
+        }
+        const result = lastMessage.result;
+        if (!internalMap.size) {
+          return this.resolve(
+            result
+          );
+        }
+        let err = false;
+        internalMap.forEach((value, key) => {
+          if (Array.isArray(result[key])) {
+            value.push(...result[key]);
+            result[key] = value;
+          } else if (value.length === 1) {
+            result[key] = value;
+          } else {
+            this.streamObject.destroy(
+              new StreamError({
+                message: "Received multiple chunks for non-array property " + key,
+                code: ERROR_TYPES.StreamError,
+                data: value
+              })
+            );
+            err = true;
+          }
+        });
+        if (!err) {
+          this.resolve(
+            result
+          );
+        }
+      }).on("error", this.reject);
+    }
+  }
+  then(onfulfilled, onrejected) {
+    this.start("promise");
+    return this.promise.then(onfulfilled, onrejected);
+  }
+  catch(onerror) {
+    this.start("promise");
+    return this.promise.catch(onerror);
+  }
+  stream() {
+    this.start("stream");
+    return this.outStreamObject;
+  }
+};
+export {
+  StreamPromise
+};

package/dist/lib/utils.browser.cjs

@@ -0,0 +1,297 @@
+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/lib/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  checkCopyObject: () => checkCopyObject,
+  copyObject: () => copyObject,
+  getConnectionParams: () => getConnectionParams,
+  getConnectionUrl: () => getConnectionUrl,
+  getForeign: () => getForeign,
+  getIdentifier: () => getIdentifier,
+  getIdentifierFilter: () => getIdentifierFilter,
+  getRandomHex: () => import_get_random_hex.getRandomHex,
+  getTxIdSync: () => getTxIdSync,
+  inputToString: () => inputToString,
+  isDateTime: () => isDateTime,
+  isFutureDate: () => isFutureDate,
+  modifyObject: () => modifyObject,
+  omit: () => omit,
+  orderByToOrder: () => orderByToOrder,
+  toQueryString: () => toQueryString,
+  validateClientFnInput: () => validateClientFnInput,
+  wait: () => wait
+});
+module.exports = __toCommonJS(utils_exports);
+var import__ = require('../index.cjs');
+var import_errors = require('./errors.cjs');
+
+// node_modules/uuid/dist/esm-browser/rng.js
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+  if (!getRandomValues) {
+    getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+    if (!getRandomValues) {
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    }
+  }
+  return getRandomValues(rnds8);
+}
+
+// node_modules/uuid/dist/esm-browser/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+
+// node_modules/uuid/dist/esm-browser/native.js
+var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native_default = {
+  randomUUID
+};
+
+// node_modules/uuid/dist/esm-browser/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// src/lib/utils.ts
+var import_get_random_hex = require('./isomorphic/web/get-random-hex.cjs');
+var internalMap = {
+  timeouts: {},
+  values: {},
+  set(key, value) {
+    this.timeouts[key] = setTimeout(() => this.clear(key), 3e4);
+    this.values[key] = value;
+  },
+  get(key) {
+    return this.values[key];
+  },
+  getKey(object) {
+    const copy = JSON.parse(JSON.stringify(object));
+    let toHash = "";
+    Object.keys(copy).sort().forEach((key) => {
+      let value = "";
+      if (copy[key] && typeof copy[key] === "object" && !Array.isArray(copy[key])) {
+        value = this.getKey(copy[key]);
+      } else {
+        value = JSON.stringify(copy[key]);
+      }
+      toHash += key + ":" + value;
+    });
+    return toHash;
+  },
+  clear(key) {
+    if (this.timeouts[key]) {
+      clearTimeout(this.timeouts[key]);
+    }
+    delete this.timeouts[key];
+    delete this.values[key];
+  },
+  clearAll() {
+    Object.keys(this.timeouts).forEach((key) => {
+      clearTimeout(this.timeouts[key]);
+    });
+    this.timeouts = {};
+    this.values = {};
+  }
+};
+function getTxIdSync(object) {
+  if (!object) {
+    return v4_default();
+  }
+  const key = internalMap.getKey(object);
+  if (internalMap.get(key)) {
+    throw new import_errors.InputError({
+      message: import__.ErrorMessage.INPUT_NEEDS_IDENTIFIER,
+      data: object
+    });
+  }
+  const value = v4_default();
+  internalMap.set(key, value);
+  return value;
+}
+function wait(time2) {
+  return new Promise((r) => setTimeout(r, time2));
+}
+function getIdentifier() {
+  return getTxIdSync();
+}
+function copyObject(input) {
+  return JSON.parse(JSON.stringify(input));
+}
+function checkCopyObject(input, property, value) {
+  if (property in input) {
+    if (input[property] === void 0) {
+      throw new import_errors.ValidationError({
+        message: `undefined provided for ${property}`,
+        data: input
+      });
+    }
+    return input;
+  }
+  if (!value) {
+    throw new import_errors.ValidationError({
+      message: `${property} is required if no default set`,
+      data: input
+    });
+  }
+  const copy = copyObject(input);
+  copy[property] = value;
+  return copy;
+}
+function omit(input, omitKey) {
+  const copy = copyObject(input);
+  delete copy[omitKey];
+  return copy;
+}
+function getForeign(value) {
+  const stringValue = inputToString(value);
+  if (stringValue === void 0 || stringValue === null) {
+    return void 0;
+  }
+  return {
+    foreign: stringValue
+  };
+}
+function getIdentifierFilter(value) {
+  const stringValue = inputToString(value);
+  if (stringValue === void 0 || stringValue === null) {
+    return void 0;
+  }
+  return {
+    identifier: stringValue
+  };
+}
+function validateClientFnInput({
+  input,
+  options,
+  validate
+}) {
+  var _a;
+  const copy = copyObject(input);
+  (_a = copy.options) != null ? _a : copy.options = options != null ? options : {};
+  return validate(copy);
+}
+function inputToString(value) {
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  return value + "";
+}
+function toQueryString(obj) {
+  return Object.keys(obj).filter((key) => obj[key] !== void 0).map(
+    (key) => `${encodeURIComponent(key)}=${encodeURIComponent(obj[key])}`
+  ).join("&");
+}
+function getConnectionUrl(config) {
+  const url = config.host.replace(/^https:/, "wss:");
+  return url + "?" + toQueryString({
+    apikey: config.apikey,
+    apisecret: config.apisecret,
+    db: config.database,
+    clientVersion: config.clientVersion
+  });
+}
+function getConnectionParams(config) {
+  if (typeof window === "undefined") {
+    return [
+      getConnectionUrl(config),
+      {
+        rejectUnauthorized: config.rejectUnauthorized
+      }
+    ];
+  }
+  return [getConnectionUrl(config)];
+}
+function modifyObject(original, modifications) {
+  const copy = {};
+  Object.keys(original).forEach((prop) => {
+    if (!modifications[prop]) {
+      copy[prop] = original[prop];
+    } else if (typeof modifications[prop] === "string") {
+      copy[modifications[prop]] = original[prop];
+    } else {
+      copy[prop] = modifications[prop](original[prop]);
+    }
+  });
+  return copy;
+}
+function orderByToOrder(orderBy) {
+  return orderBy.split(",").map((str) => str.split(" ")).map((split) => {
+    const [field, direction] = split;
+    return {
+      field,
+      direction: direction === "desc" ? "desc" : "asc"
+    };
+  });
+}
+function isFutureDate(dateString) {
+  return new Date(dateString).setHours(0, 0, 0, 0) > (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0);
+}
+function isLeapYear(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function isDate(str) {
+  const matches = DATE.exec(str);
+  if (!matches) return false;
+  const year = +matches[1];
+  const month = +matches[2];
+  const day = +matches[3];
+  return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
+}
+var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
+function time(str, withTimeZone) {
+  const matches = TIME.exec(str);
+  if (!matches) return false;
+  const hour = +matches[1];
+  const minute = +matches[2];
+  const second = +matches[3];
+  const timeZone = matches[5];
+  return (hour <= 23 && minute <= 59 && second <= 59 || hour === 23 && minute === 59 && second === 60) && (!withTimeZone || timeZone !== "");
+}
+var DATE_TIME_SEPARATOR = /t|\s/i;
+function isDateTime(str) {
+  const dateTime = str.split(DATE_TIME_SEPARATOR);
+  if (dateTime.length === 1) {
+    return isDate(dateTime[0]);
+  }
+  return dateTime.length === 2 && isDate(dateTime[0]) && time(dateTime[1]);
+}