@leofcoin/codec-format-interface 1.0.1 → 1.2.0

package/dist/index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 var bs32 = require('@vandeurenglenn/base32');
 var bs58 = require('@vandeurenglenn/base58');
 var isHex = require('@vandeurenglenn/is-hex');
@@ -8,6 +10,24 @@ var createKeccakHash = require('keccak');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
 var bs32__default = /*#__PURE__*/_interopDefaultLegacy(bs32);
 var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
 var isHex__default = /*#__PURE__*/_interopDefaultLegacy(isHex);
@@ -17,12 +37,12 @@ var createKeccakHash__default = /*#__PURE__*/_interopDefaultLegacy(createKeccakH
 class BasicInterface {
   #handleDecode() {
     if (!this.decode) throw new Error('bad implementation: needs decode func')
-    this.decode();
+    return this.decode()
   }
 
   #handleEncode() {
     if (!this.encode) throw new Error('bad implementation: needs encode func')
-    this.encode();
+    return this.encode()
   }
   isHex(string) {
     return isHex__default["default"](string)
@@ -83,8 +103,8 @@ class BasicInterface {
     return this.#handleDecode()
   }
 
-  toString(encoding = 'utf8') {
-    if (!this.encoded) this.#handleEncode();
+  async toString(encoding = 'utf8') {
+    if (!this.encoded) await this.#handleEncode();
     return this.encoded.toString(encoding)
   }
 
@@ -98,16 +118,16 @@ class BasicInterface {
   /**
    * @return {String} encoded
    */
-  toBs32() {
-    if (!this.encoded) this.#handleEncode();
+  async toBs32() {
+    if (!this.encoded) await this.#handleEncode();
     return bs32__default["default"].encode(this.encoded)
   }
 
   /**
    * @return {String} encoded
    */
-  toBs58() {
-    if (!this.encoded) this.#handleEncode();
+  async toBs58() {
+    if (!this.encoded) await this.#handleEncode();
     return bs58__default["default"].encode(this.encoded)
   }
 
@@ -129,11 +149,16 @@ class BasicInterface {
       }
 
       this.decoded = decoded;
-      this.encode();
+      return this.encode()
     }
   }
 }
 
+var basicInterface = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  'default': BasicInterface
+});
+
 var codecs = {
   // just a hash
   'disco-hash': {
@@ -214,6 +239,11 @@ var codecs = {
   },
 };
 
+var codecs$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  'default': codecs
+});
+
 class PeernetCodec extends BasicInterface {
   get codecs() {
     return {...globalThis.peernet.codecs, ...codecs}
@@ -305,6 +335,11 @@ class PeernetCodec extends BasicInterface {
   }
 }
 
+var codec = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  'default': PeernetCodec
+});
+
 class CodecHash extends BasicInterface {
   constructor(buffer, options = {}) {
     super();
@@ -428,7 +463,44 @@ class CodecHash extends BasicInterface {
   }
 }
 
+var codecHash = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  'default': CodecHash
+});
+
+let protons;
+
 class FormatInterface extends BasicInterface {
+  async #importProtons() {
+    let importee = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(/* webpackChunkName: "protons" */ 'protons')); });
+    return importee.default
+  }
+
+  async protoEncode(data) {
+    if (!protons) protons = await this.#importProtons();
+    return protons(this.proto)[this.messageName].encode(data)
+  }
+
+  async protoDecode(data) {
+    if (!protons) protons = await this.#importProtons();
+    return protons(this.proto)[this.messageName].decode(data)
+  }
+
+  async #init(buffer) {
+    if (buffer instanceof Uint8Array) await this.fromUint8Array(buffer);
+    else if (buffer instanceof ArrayBuffer) await this.fromArrayBuffer(buffer);
+    else if (buffer?.name === this.name) return buffer
+    else if (buffer instanceof String) {
+      if (this.isHex(buffer)) await this.fromHex(buffer);
+      else if (this.isBase32(buffer)) await this.fromBs32(buffer);
+      else if (this.isBase58(buffer)) await this.fromBs58(buffer);
+      else throw new Error(`unsupported string ${buffer}`)
+    } else {
+      await this.create(buffer);
+    }
+    return this
+  }
+
   /**
    * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
    * @param {Object} proto - {encode, decode}
@@ -436,21 +508,10 @@ class FormatInterface extends BasicInterface {
    */
   constructor(buffer, proto, options = {}) {
     super();
-    this.protoEncode = proto.encode;
-    this.protoDecode = proto.decode;
+    this.proto = proto;
     this.hashFormat = options.hashFormat || 'bs32';
     if (options.name) this.name = options.name;
-    if (buffer instanceof Uint8Array) this.fromUint8Array(buffer);
-    else if (buffer instanceof ArrayBuffer) this.fromArrayBuffer(buffer);
-    else if (buffer.name === options.name) return buffer
-    else if (buffer instanceof String) {
-      if (this.isHex(buffer)) this.fromHex(buffer);
-      else if (this.isBase32(buffer)) this.fromBs32(buffer);
-      else if (this.isBase58(buffer)) this.fromBs58(buffer);
-      else throw new Error(`unsupported string ${buffer}`)
-    } else {
-      this.create(buffer);
-    }
+    return this.#init(buffer)
   }
 
   /**
@@ -472,22 +533,22 @@ class FormatInterface extends BasicInterface {
   /**
    * @return {Object}
    */
-  decode() {
+  async decode() {
     let encoded = this.encoded;
     const discoCodec = new PeernetCodec(this.encoded);
     encoded = encoded.slice(discoCodec.codecBuffer.length);
     this.name = discoCodec.name;
-    this.decoded = this.protoDecode(encoded);
+    this.decoded = await this.protoDecode(encoded);
     return this.decoded
   }
 
   /**
    * @return {Buffer}
    */
-  encode(decoded) {
+  async encode(decoded) {
     if (!decoded) decoded = this.decoded;
     const codec = new PeernetCodec(this.name);
-    const encoded = this.protoEncode(decoded);
+    const encoded = await this.protoEncode(decoded);
     const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
     uint8Array.set(codec.codecBuffer);
     uint8Array.set(encoded, codec.codecBuffer.length);
@@ -503,21 +564,26 @@ class FormatInterface extends BasicInterface {
 
   fromUint8Array(buffer) {
     this.encoded = buffer;
-    if (!this.hasCodec()) this.create(
+    return this.hasCodec() ? this.decode() : 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(
+    return this.hasCodec() ? this.decode() : this.create(
       JSON.parse(new TextDecoder().decode(this.encoded))
-    );
-    else this.decode();
+    )
   }
 }
 
-var index = { codecs, Codec: PeernetCodec, CodecHash, FormatInterface, BasicInterface };
+var codecFormatInterface = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  'default': FormatInterface
+});
 
-module.exports = index;
+exports.BasicInterface = basicInterface;
+exports.Codec = codec;
+exports.CodecHash = codecHash;
+exports.FormatInterface = codecFormatInterface;
+exports.codecs = codecs$1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/codec-format-interface",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "",
   "main": "dist/index.js",
   "module": "src/index.js",
@@ -24,6 +24,7 @@
     "@vandeurenglenn/base58": "^1.1.0",
     "@vandeurenglenn/is-hex": "^1.0.0",
     "keccak": "^3.0.2",
+    "protons": "^2.0.1",
     "varint": "^6.0.0"
   },
   "devDependencies": {

package/src/basic-interface.js

@@ -5,12 +5,12 @@ import isHex from '@vandeurenglenn/is-hex';
 export default class BasicInterface {
   #handleDecode() {
     if (!this.decode) throw new Error('bad implementation: needs decode func')
-    this.decode()
+    return this.decode()
   }
 
   #handleEncode() {
     if (!this.encode) throw new Error('bad implementation: needs encode func')
-    this.encode()
+    return this.encode()
   }
   isHex(string) {
     return isHex(string)
@@ -71,8 +71,8 @@ export default class BasicInterface {
     return this.#handleDecode()
   }
 
-  toString(encoding = 'utf8') {
-    if (!this.encoded) this.#handleEncode()
+  async toString(encoding = 'utf8') {
+    if (!this.encoded) await this.#handleEncode()
     return this.encoded.toString(encoding)
   }
 
@@ -86,16 +86,16 @@ export default class BasicInterface {
   /**
    * @return {String} encoded
    */
-  toBs32() {
-    if (!this.encoded) this.#handleEncode()
+  async toBs32() {
+    if (!this.encoded) await this.#handleEncode()
     return bs32.encode(this.encoded)
   }
 
   /**
    * @return {String} encoded
    */
-  toBs58() {
-    if (!this.encoded) this.#handleEncode()
+  async toBs58() {
+    if (!this.encoded) await this.#handleEncode()
     return bs58.encode(this.encoded)
   }
 
@@ -117,7 +117,7 @@ export default class BasicInterface {
       }
 
       this.decoded = decoded
-      this.encode()
+      return this.encode()
     }
   }
 }

package/src/codec-format-interface.js

@@ -1,8 +1,39 @@
 import BasicInterface from './basic-interface.js'
 import Codec from './codec.js';
 import Hash from './codec-hash.js'
+let protons
 
 export default class FormatInterface extends BasicInterface {
+  async #importProtons() {
+    let importee = await import(/* webpackChunkName: "protons" */ 'protons')
+    return importee.default
+  }
+
+  async protoEncode(data) {
+    if (!protons) protons = await this.#importProtons()
+    return protons(this.proto)[this.messageName].encode(data)
+  }
+
+  async protoDecode(data) {
+    if (!protons) protons = await this.#importProtons()
+    return protons(this.proto)[this.messageName].decode(data)
+  }
+
+  async #init(buffer) {
+    if (buffer instanceof Uint8Array) await this.fromUint8Array(buffer)
+    else if (buffer instanceof ArrayBuffer) await this.fromArrayBuffer(buffer)
+    else if (buffer?.name === this.name) return buffer
+    else if (buffer instanceof String) {
+      if (this.isHex(buffer)) await this.fromHex(buffer)
+      else if (this.isBase32(buffer)) await this.fromBs32(buffer)
+      else if (this.isBase58(buffer)) await this.fromBs58(buffer)
+      else throw new Error(`unsupported string ${buffer}`)
+    } else {
+      await this.create(buffer)
+    }
+    return this
+  }
+
   /**
    * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
    * @param {Object} proto - {encode, decode}
@@ -10,21 +41,10 @@ export default class FormatInterface extends BasicInterface {
    */
   constructor(buffer, proto, options = {}) {
     super()
-    this.protoEncode = proto.encode
-    this.protoDecode = proto.decode
+    this.proto = proto
     this.hashFormat = options.hashFormat || 'bs32'
     if (options.name) this.name = options.name
-    if (buffer instanceof Uint8Array) this.fromUint8Array(buffer)
-    else if (buffer instanceof ArrayBuffer) this.fromArrayBuffer(buffer)
-    else if (buffer.name === options.name) return buffer
-    else if (buffer instanceof String) {
-      if (this.isHex(buffer)) this.fromHex(buffer)
-      else if (this.isBase32(buffer)) this.fromBs32(buffer)
-      else if (this.isBase58(buffer)) this.fromBs58(buffer)
-      else throw new Error(`unsupported string ${buffer}`)
-    } else {
-      this.create(buffer)
-    }
+    return this.#init(buffer)
   }
 
   /**
@@ -46,22 +66,22 @@ export default class FormatInterface extends BasicInterface {
   /**
    * @return {Object}
    */
-  decode() {
+  async decode() {
     let encoded = this.encoded;
     const discoCodec = new Codec(this.encoded)
     encoded = encoded.slice(discoCodec.codecBuffer.length)
     this.name = discoCodec.name
-    this.decoded = this.protoDecode(encoded)
+    this.decoded = await this.protoDecode(encoded)
     return this.decoded
   }
 
   /**
    * @return {Buffer}
    */
-  encode(decoded) {
+  async encode(decoded) {
     if (!decoded) decoded = this.decoded;
     const codec = new Codec(this.name)
-    const encoded = this.protoEncode(decoded)
+    const encoded = await this.protoEncode(decoded)
     const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length)
     uint8Array.set(codec.codecBuffer)
     uint8Array.set(encoded, codec.codecBuffer.length)
@@ -77,17 +97,15 @@ export default class FormatInterface extends BasicInterface {
 
   fromUint8Array(buffer) {
     this.encoded = buffer
-    if (!this.hasCodec()) this.create(
+    return this.hasCodec() ? this.decode() : 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(
+    return this.hasCodec() ? this.decode() : this.create(
       JSON.parse(new TextDecoder().decode(this.encoded))
     )
-    else this.decode()
   }
 }

package/src/index.js

@@ -1,7 +1,5 @@
-import BasicInterface from './basic-interface.js'
-import FormatInterface from './codec-format-interface.js'
-import CodecHash from './codec-hash.js'
-import Codec from './codec.js'
-import codecs from './codecs.js'
-
-export default { codecs, Codec, CodecHash, FormatInterface, BasicInterface }
+export * as BasicInterface from './basic-interface.js'
+export * as FormatInterface from './codec-format-interface.js'
+export * as CodecHash from './codec-hash.js'
+export * as Codec from './codec.js'
+export * as codecs from './codecs.js'

package/test/test.js

@@ -1,9 +1,26 @@
 const test = require('tape');
 const {FormatInterface} = require('./../dist/index')
 
-test('', tape => {
-  tape.plan(1)
-  const int = new FormatInterface()
-  console.log(int);
-  tape.plan('ok')
+globalThis.peernet = {codecs: {}}
+class FormatTest extends FormatInterface {
+  get keys() { return ['somedata'] }
+  get messageName() { return 'Message' }
+
+  constructor(data) {
+    super(data, `message Message {
+      required string somedata = 1;
+    }`, {name: 'disco-hash'})
+  }
+}
+
+const encoded =  [48,  10,   5, 104, 101, 108, 108, 111]
+
+test('format', async  (tape) => {
+  tape.plan(2)
+  const message = await new FormatTest({somedata: 'hello'})
+  await message.encode()
+  const m2 = await new FormatTest(message.encoded)
+  await m2.decode()
+  tape.ok(message.encoded, 'can encode')
+  tape.ok(m2.decoded.somedata === 'hello', 'can decode')
 })