@leofcoin/peernet 0.11.0 → 0.11.1

package/dist/commonjs/{client-bd0caeb7.js → client-1a1f75e6.js}

@@ -229,47 +229,47 @@ const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry
   });
 };
 
-class HttpClientApi$1 {
-  constructor(config = {}) {
-    if (!config.apiPath) config.apiPath = 'api';
-
-    const address = `ws://${config.host}:${config.port}`;
-
-    this.apiUrl = (url) => `${address}/${url}`;
-    return (async () => {
-      this.client = await socketRequestClient(address, config.protocol, {pubsub: config.pubsub, retry: 3000});
-      return this
-    })()
-  }
-
-  async get(url, obj) {
-    const headers = {};
-    let body = null;
-    let method = 'GET';
-    if (obj) {
-      method = 'POST';
-      headers['Content-Type'] = 'application/json';
-      body = JSON.stringify(obj);
-    }
-    let response = await this.client.request(url, {headers, body, method});
-    const type = response.headers.get('content-type').split(';')[0];
-    if (type==='application/json') response = await response.json();
-    return response
-  }
-
-  async put(url, obj) {
-    const headers = {};
-    let body = {};
-    if (obj) {
-      headers['Content-Type'] = 'application/json';
-      body = JSON.stringify(obj);
-    }
-
-    let response = await fetch(this.apiUrl(url), {method: 'PUT', headers, body});
-    const type = response.headers.get('content-type').split(';')[0];
-    if (type==='application/json') response = await response.json();
-    return response
-  }
+class HttpClientApi$1 {
+  constructor(config = {}) {
+    if (!config.apiPath) config.apiPath = 'api';
+
+    const address = `ws://${config.host}:${config.port}`;
+
+    this.apiUrl = (url) => `${address}/${url}`;
+    return (async () => {
+      this.client = await socketRequestClient(address, config.protocol, {pubsub: config.pubsub, retry: 3000});
+      return this
+    })()
+  }
+
+  async get(url, obj) {
+    const headers = {};
+    let body = null;
+    let method = 'GET';
+    if (obj) {
+      method = 'POST';
+      headers['Content-Type'] = 'application/json';
+      body = JSON.stringify(obj);
+    }
+    let response = await this.client.request(url, {headers, body, method});
+    const type = response.headers.get('content-type').split(';')[0];
+    if (type==='application/json') response = await response.json();
+    return response
+  }
+
+  async put(url, obj) {
+    const headers = {};
+    let body = {};
+    if (obj) {
+      headers['Content-Type'] = 'application/json';
+      body = JSON.stringify(obj);
+    }
+
+    let response = await fetch(this.apiUrl(url), {method: 'PUT', headers, body});
+    const type = response.headers.get('content-type').split(';')[0];
+    if (type==='application/json') response = await response.json();
+    return response
+  }
 }
 
 class HttpClientApi extends HttpClientApi$1 {

package/dist/commonjs/{codec-4a768e5e.js → codec-8c8c652f.js}

@@ -3,7 +3,7 @@
 var varint = require('varint');
 var bs32 = require('@vandeurenglenn/base32');
 var bs58 = require('@vandeurenglenn/base58');
-var isHex = require('is-hex');
+var isHex = require('@vandeurenglenn/is-hex');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -92,123 +92,123 @@ var codecs = {
   },
 };
 
-class PeernetCodec {
-  get codecs() {
-    return {...globalThis.peernet.codecs, ...codecs}
-  }
-  constructor(buffer) {
-    if (buffer) {
-      if (buffer instanceof Uint8Array) {
-        const codec = varint__default["default"].decode(buffer);
-        const name = this.getCodecName(codec);
-        if (name) {
-          this.name = name;
-          this.encoded = buffer;
-          this.decode(buffer);
-        } else {
-          this.encode(buffer);
-        }
-      } else if (buffer instanceof ArrayBuffer) {
-        const encoded = new Uint8Array(buffer.byteLength);
-
-        for (let i = 0; i < buffer.byteLength; i++) {
-          encoded[i] = buffer[i];
-        }
-        this.encoded = encoded;
-        // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
-        this.decode(buffer);
-        return
-      }
-      if (typeof buffer === 'string') {
-        if (this.codecs[buffer]) this.fromName(buffer);
-        else if (isHex__default["default"](buffer)) this.fromHex(buffer);
-        else if (bs32__default["default"].isBase32(buffer)) this.fromBs32(buffer);
-        else if (bs58__default["default"].isBase58(buffer)) this.fromBs58(buffer);
-        else throw new Error(`unsupported string ${buffer}`)
-      }
-      if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer);
-    }
-  }
-
-  fromEncoded(encoded) {
-    const codec = varint__default["default"].decode(encoded);
-    const name = this.getCodecName(codec);
-    this.name = name;
-    this.encoded = encoded;
-    this.decode(encoded);
-  }
-
-  fromHex(hex) {
-    this.encoded = Buffer.from(hex, 'hex');
-    this.decode();
-  }
-
-  fromBs32(input) {
-    this.encoded = bs32__default["default"].decode(input);
-    this.decode();
-  }
-
-  fromBs58(input) {
-    this.encoded = bs58__default["default"].decode(input);
-    this.decode();
-  }
-
-  getCodec(name) {
-    return this.codecs[name].codec
-  }
-
-  getCodecName(codec) {
-    return Object.keys(this.codecs).reduce((p, c) => {
-      const item = this.codecs[c];
-      if (item.codec === codec) return c;
-      else return p;
-    }, undefined)
-  }
-
-  getHashAlg(name) {
-    return this.codecs[name].hashAlg
-  }
-
-  fromCodec(codec) {
-    this.name = this.getCodecName(codec);
-    this.hashAlg = this.getHashAlg(this.name);
-
-    this.codec = this.getCodec(this.name);
-    this.codecBuffer = varint__default["default"].encode(codec);
-  }
-
-  fromName(name) {
-    const codec = this.getCodec(name);
-    this.name = name;
-    this.codec = codec;
-    this.hashAlg = this.getHashAlg(name);
-    this.codecBuffer = varint__default["default"].encode(codec);
-  }
-
-  toBs32() {
-    this.encode();
-    return bs32__default["default"].encode(this.encoded)
-  }
-
-  toBs58() {
-    this.encode();
-    return bs58__default["default"].encode(this.encoded)
-  }
-
-  toHex() {
-    return this.encoded.toString('hex')
-  }
-
-  decode() {
-    const codec = varint__default["default"].decode(this.encoded);
-    this.fromCodec(codec);
-  }
-
-  encode() {
-    const codec = varint__default["default"].encode(this.decoded);
-    this.encoded = codec;
-    return this.encoded
-  }
+class PeernetCodec {
+  get codecs() {
+    return {...globalThis.peernet.codecs, ...codecs}
+  }
+  constructor(buffer) {
+    if (buffer) {
+      if (buffer instanceof Uint8Array) {
+        const codec = varint__default["default"].decode(buffer);
+        const name = this.getCodecName(codec);
+        if (name) {
+          this.name = name;
+          this.encoded = buffer;
+          this.decode(buffer);
+        } else {
+          this.encode(buffer);
+        }
+      } else if (buffer instanceof ArrayBuffer) {
+        const encoded = new Uint8Array(buffer.byteLength);
+
+        for (let i = 0; i < buffer.byteLength; i++) {
+          encoded[i] = buffer[i];
+        }
+        this.encoded = encoded;
+        // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
+        this.decode(buffer);
+        return
+      }
+      if (typeof buffer === 'string') {
+        if (this.codecs[buffer]) this.fromName(buffer);
+        else if (isHex__default["default"](buffer)) this.fromHex(buffer);
+        else if (bs32__default["default"].isBase32(buffer)) this.fromBs32(buffer);
+        else if (bs58__default["default"].isBase58(buffer)) this.fromBs58(buffer);
+        else throw new Error(`unsupported string ${buffer}`)
+      }
+      if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer);
+    }
+  }
+
+  fromEncoded(encoded) {
+    const codec = varint__default["default"].decode(encoded);
+    const name = this.getCodecName(codec);
+    this.name = name;
+    this.encoded = encoded;
+    this.decode(encoded);
+  }
+
+  fromHex(hex) {
+    this.encoded = Buffer.from(hex, 'hex');
+    this.decode();
+  }
+
+  fromBs32(input) {
+    this.encoded = bs32__default["default"].decode(input);
+    this.decode();
+  }
+
+  fromBs58(input) {
+    this.encoded = bs58__default["default"].decode(input);
+    this.decode();
+  }
+
+  getCodec(name) {
+    return this.codecs[name].codec
+  }
+
+  getCodecName(codec) {
+    return Object.keys(this.codecs).reduce((p, c) => {
+      const item = this.codecs[c];
+      if (item.codec === codec) return c;
+      else return p;
+    }, undefined)
+  }
+
+  getHashAlg(name) {
+    return this.codecs[name].hashAlg
+  }
+
+  fromCodec(codec) {
+    this.name = this.getCodecName(codec);
+    this.hashAlg = this.getHashAlg(this.name);
+
+    this.codec = this.getCodec(this.name);
+    this.codecBuffer = varint__default["default"].encode(codec);
+  }
+
+  fromName(name) {
+    const codec = this.getCodec(name);
+    this.name = name;
+    this.codec = codec;
+    this.hashAlg = this.getHashAlg(name);
+    this.codecBuffer = varint__default["default"].encode(codec);
+  }
+
+  toBs32() {
+    this.encode();
+    return bs32__default["default"].encode(this.encoded)
+  }
+
+  toBs58() {
+    this.encode();
+    return bs58__default["default"].encode(this.encoded)
+  }
+
+  toHex() {
+    return this.encoded.toString('hex')
+  }
+
+  decode() {
+    const codec = varint__default["default"].decode(this.encoded);
+    this.fromCodec(codec);
+  }
+
+  encode() {
+    const codec = varint__default["default"].encode(this.decoded);
+    this.encoded = codec;
+    return this.encoded
+  }
 }
 
 exports.PeernetCodec = PeernetCodec;

package/dist/commonjs/codec-format-interface.js

@@ -2,8 +2,8 @@
 
 var bs32 = require('@vandeurenglenn/base32');
 var bs58 = require('@vandeurenglenn/base58');
-var isHex = require('is-hex');
-var codec = require('./codec-4a768e5e.js');
+var isHex = require('@vandeurenglenn/is-hex');
+var codec = require('./codec-8c8c652f.js');
 var hash = require('./hash.js');
 require('varint');
 require('keccak');
@@ -14,171 +14,171 @@ var bs32__default = /*#__PURE__*/_interopDefaultLegacy(bs32);
 var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
 var isHex__default = /*#__PURE__*/_interopDefaultLegacy(isHex);
 
-class FormatInterface {
-  /**
-   * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
-   * @param {Object} proto - {encode, decode}
-   * @param {Object} options - {hashFormat, name}
-   */
-  constructor(buffer, proto, options = {}) {
-    this.protoEncode = proto.encode;
-    this.protoDecode = proto.decode;
-    this.hashFormat = options.hashFormat || 'bs32';
-    if (options.name) this.name = options.name;
-    if (buffer instanceof Uint8Array) return this.fromUint8Array(buffer)
-    else if (buffer instanceof ArrayBuffer) return this.fromArrayBuffer(buffer)
-    else if (buffer.name === options.name) return buffer
-    else if (typeof buffer === 'string') {
-        if (isHex__default["default"](buffer)) this.fromHex(buffer);
-        else if (bs32__default["default"].isBase32(buffer)) this.fromBs32(buffer);
-        else if (bs58__default["default"].isBase58(buffer)) this.fromBs58(buffer);
-        else throw new Error(`unsupported string ${buffer}`)
-    } else {
-      this.create(buffer);
-    }
-  }
-
-  /**
-   * @return {PeernetHash}
-   */
-  get peernetHash() {
-    return new hash(this.decoded, {name: this.name})
-  }
-
-  /**
-   * @return {peernetHash}
-   */
-  get hash() {
-    const upper = this.hashFormat.charAt(0).toUpperCase();
-    const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
-    return this.peernetHash[`to${format}`]()
-  }
-
-  /**
-   * @return {Object}
-   */
-  decode() {
-    let encoded = this.encoded;
-    const discoCodec = new codec.PeernetCodec(this.encoded);
-    encoded = encoded.slice(discoCodec.codecBuffer.length);
-    this.name = discoCodec.name;
-    this.decoded = this.protoDecode(encoded);
-    return this.decoded
-  }
-
-  /**
-   * @return {Buffer}
-   */
-  encode(decoded) {
-    if (!decoded) decoded = this.decoded;
-    const codec$1 = new codec.PeernetCodec(this.name);
-    const encoded = this.protoEncode(decoded);
-    const uint8Array = new Uint8Array(encoded.length + codec$1.codecBuffer.length);
-    uint8Array.set(codec$1.codecBuffer);
-    uint8Array.set(encoded, codec$1.codecBuffer.length);
-    this.encoded = uint8Array;
-    return this.encoded
-  }
-
-  hasCodec() {
-    if (!this.encoded) return false
-    const codec$1 = new codec.PeernetCodec(this.encoded);
-    if (codec$1.name) return true
-  }
-
-  fromUint8Array(buffer) {
-    this.encoded = buffer;
-    if (!this.hasCodec()) this.create(
-      JSON.parse(new TextDecoder().decode(this.encoded))
-    );
-    else this.decode();
-  }
-
-  fromArrayBuffer(buffer) {
-    this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
-    if (!this.hasCodec()) this.create(
-      JSON.parse(new TextDecoder().decode(this.encoded))
-    );
-    else this.decode();
-  }
-
-  /**
-   * @param {Buffer} encoded
-   */
-  fromEncoded(encoded) {
-    this.encoded = encoded;
-    this.decode();
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  fromHex(encoded) {
-    this.encoded = Buffer.from(encoded, 'hex');
-    this.decode();
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  fromBs32(encoded) {
-    this.encoded = bs32__default["default"].decode(encoded);
-    this.decode();
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  fromBs58(encoded) {
-    this.encoded = bs58__default["default"].decode(encoded);
-    this.decode();
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toHex() {
-    if (!this.encoded) this.encode();
-    return this.encoded.toString('hex')
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toBs32() {
-    if (!this.encoded) this.encode();
-    return bs32__default["default"].encode(this.encoded)
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toBs58() {
-    if (!this.encoded) this.encode();
-    return bs58__default["default"].encode(this.encoded)
-  }
-
-  /**
-   * @param {Object} data
-   */
-  create(data) {
-    const decoded = {};
-    if (this.keys?.length > 0) {
-      for (const key of this.keys) {
-        Object.defineProperties(decoded, {
-          [key]: {
-            enumerable: true,
-            configurable: true,
-            set: (val) => value = data[key],
-            get: () => data[key]
-          }
-        });
-      }
-
-      this.decoded = decoded;
-      this.encode();
-    }
-  }
+class FormatInterface {
+  /**
+   * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
+   * @param {Object} proto - {encode, decode}
+   * @param {Object} options - {hashFormat, name}
+   */
+  constructor(buffer, proto, options = {}) {
+    this.protoEncode = proto.encode;
+    this.protoDecode = proto.decode;
+    this.hashFormat = options.hashFormat || 'bs32';
+    if (options.name) this.name = options.name;
+    if (buffer instanceof Uint8Array) return this.fromUint8Array(buffer)
+    else if (buffer instanceof ArrayBuffer) return this.fromArrayBuffer(buffer)
+    else if (buffer.name === options.name) return buffer
+    else if (typeof buffer === 'string') {
+        if (isHex__default["default"](buffer)) this.fromHex(buffer);
+        else if (bs32__default["default"].isBase32(buffer)) this.fromBs32(buffer);
+        else if (bs58__default["default"].isBase58(buffer)) this.fromBs58(buffer);
+        else throw new Error(`unsupported string ${buffer}`)
+    } else {
+      this.create(buffer);
+    }
+  }
+
+  /**
+   * @return {PeernetHash}
+   */
+  get peernetHash() {
+    return new hash(this.decoded, {name: this.name})
+  }
+
+  /**
+   * @return {peernetHash}
+   */
+  get hash() {
+    const upper = this.hashFormat.charAt(0).toUpperCase();
+    const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
+    return this.peernetHash[`to${format}`]()
+  }
+
+  /**
+   * @return {Object}
+   */
+  decode() {
+    let encoded = this.encoded;
+    const discoCodec = new codec.PeernetCodec(this.encoded);
+    encoded = encoded.slice(discoCodec.codecBuffer.length);
+    this.name = discoCodec.name;
+    this.decoded = this.protoDecode(encoded);
+    return this.decoded
+  }
+
+  /**
+   * @return {Buffer}
+   */
+  encode(decoded) {
+    if (!decoded) decoded = this.decoded;
+    const codec$1 = new codec.PeernetCodec(this.name);
+    const encoded = this.protoEncode(decoded);
+    const uint8Array = new Uint8Array(encoded.length + codec$1.codecBuffer.length);
+    uint8Array.set(codec$1.codecBuffer);
+    uint8Array.set(encoded, codec$1.codecBuffer.length);
+    this.encoded = uint8Array;
+    return this.encoded
+  }
+
+  hasCodec() {
+    if (!this.encoded) return false
+    const codec$1 = new codec.PeernetCodec(this.encoded);
+    if (codec$1.name) return true
+  }
+
+  fromUint8Array(buffer) {
+    this.encoded = buffer;
+    if (!this.hasCodec()) this.create(
+      JSON.parse(new TextDecoder().decode(this.encoded))
+    );
+    else this.decode();
+  }
+
+  fromArrayBuffer(buffer) {
+    this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
+    if (!this.hasCodec()) this.create(
+      JSON.parse(new TextDecoder().decode(this.encoded))
+    );
+    else this.decode();
+  }
+
+  /**
+   * @param {Buffer} encoded
+   */
+  fromEncoded(encoded) {
+    this.encoded = encoded;
+    this.decode();
+  }
+
+  /**
+   * @param {String} encoded
+   */
+  fromHex(encoded) {
+    this.encoded = Buffer.from(encoded, 'hex');
+    this.decode();
+  }
+
+  /**
+   * @param {String} encoded
+   */
+  fromBs32(encoded) {
+    this.encoded = bs32__default["default"].decode(encoded);
+    this.decode();
+  }
+
+  /**
+   * @param {String} encoded
+   */
+  fromBs58(encoded) {
+    this.encoded = bs58__default["default"].decode(encoded);
+    this.decode();
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  toHex() {
+    if (!this.encoded) this.encode();
+    return this.encoded.toString('hex')
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  toBs32() {
+    if (!this.encoded) this.encode();
+    return bs32__default["default"].encode(this.encoded)
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  toBs58() {
+    if (!this.encoded) this.encode();
+    return bs58__default["default"].encode(this.encoded)
+  }
+
+  /**
+   * @param {Object} data
+   */
+  create(data) {
+    const decoded = {};
+    if (this.keys?.length > 0) {
+      for (const key of this.keys) {
+        Object.defineProperties(decoded, {
+          [key]: {
+            enumerable: true,
+            configurable: true,
+            set: (val) => value = data[key],
+            get: () => data[key]
+          }
+        });
+      }
+
+      this.decoded = decoded;
+      this.encode();
+    }
+  }
 }
 
 module.exports = FormatInterface;