@leofcoin/codec-format-interface 1.5.2 → 1.5.3

package/README.md

@@ -1,2 +1,32 @@
 # codec-format-interface
  
+## usage 
+
+```js
+import FormatInterface from '@leofcoin/codec-format-interface'
+
+class MyFormat extends FormatInterface {
+  get proto() {
+    return {
+      key: 'value',
+      hello: 'world'
+    }
+  }
+
+  constructor(data) {
+    super(data, { name: 'my-format', hashFormat = 'bs32' })
+  }
+}
+
+```
+
+## build for browser
+### rollup
+```js
+import resolve from '@rollup/plugin-node-resolve'
+...
+  plugins: [
+    resolve()
+  ]
+...
+```

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@leofcoin/codec-format-interface",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "",
-  "main": "dist/index.js",
   "type": "module",
-  "typings": "typings/basicInterface.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "typings": "dist/index.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "rollup -c"
@@ -24,6 +26,8 @@
     "@vandeurenglenn/base32": "^1.1.0",
     "@vandeurenglenn/base58": "^1.1.1",
     "@vandeurenglenn/is-hex": "^1.0.0",
+    "@vandeurenglenn/proto-array": "^1.0.0",
+    "@vandeurenglenn/typed-array-utils": "^1.1.0",
     "hash-wasm": "^4.9.0",
     "varint": "^6.0.0"
   },

package/rollup.config.js

@@ -1,6 +1,6 @@
-import resolve from '@rollup/plugin-node-resolve'
-import commonjs from '@rollup/plugin-commonjs'
 import typescript from '@rollup/plugin-typescript'
+import tsConfig from './tsconfig.json' assert { type: 'json' }
+
 export default [{
   input: ['src/index.ts'],
   output: [{
@@ -8,8 +8,6 @@ export default [{
     format: 'es'
   }],
   plugins: [
-    commonjs(),
-    resolve({preferBuiltins: true}),
-    typescript()
+    typescript(tsConfig)
   ]
 }]

package/src/basic-interface.ts

@@ -1,29 +1,28 @@
 import bs32 from '@vandeurenglenn/base32';
 import base58 from '@vandeurenglenn/base58';
 import isHex from '@vandeurenglenn/is-hex';
+import proto from '@vandeurenglenn/proto-array'
+import { fromBase32, fromBase58, fromString, fromHex, fromArrayLike, fromUintArrayString, toBase32, toBase58, toHex } from '@vandeurenglenn/typed-array-utils'
 
 
-export default class BasicInterface implements basicInterface {
+export default class BasicInterface {
   encoded: Uint8Array;
   decoded: object | string;
   keys: string[]
   name: string
   // get Codec(): Codec {}
 
-  async protoEncode(data: string): Promise<Uint8Array> {
+  protoEncode(data: object): Uint8Array {
     // check schema
-    return new TextEncoder().encode(data)
+    
+    return proto.encode(this.proto, data)
   }
 
-  async protoDecode(data: Uint8Array): Promise<string> {
+  protoDecode(data: Uint8Array): object {
     // check schema
-    return new TextDecoder().decode(data)
+    return proto.decode(this.proto, data)
   }
 
-  decode: () => DecodeResult;
-  
-  encode:() => Promise<Uint8Array>;
-
   isHex(string: any) {
     return isHex(string)
   }
@@ -34,14 +33,14 @@ export default class BasicInterface implements basicInterface {
     return base58.isBase58(string)
   }
 
-  fromBs32(encoded: base58): DecodeResult {
+  fromBs32(encoded: base58String): object {
     this.encoded = bs32.decode(encoded)
     return this.decode()
   }
 
 
-  fromBs58(encoded: any): DecodeResult {
-    this.encoded = base58.decode(encoded)
+  fromBs58(encoded: any): object {
+    this.encoded = fromBase58(encoded)
     return this.decode()
   }
 
@@ -60,6 +59,11 @@ export default class BasicInterface implements basicInterface {
     return this.decode()
   }
 
+  fromHex(string) {
+    this.encoded = fromHex(string)
+    return this.decode()
+  }
+
   fromArray(array: number[]): object {
     this.encoded = Uint8Array.from([...array])
     return this.decode()
@@ -70,37 +74,30 @@ export default class BasicInterface implements basicInterface {
     return this.decode()
   }
 
-  fromHex(encoded: string): Promise<string | object> {
-    this.encoded = Buffer.from(encoded, 'hex')
-    return this.decode()
-  }
-
-  async toString(encoding: string = 'utf8'): Promise<string> {
-    if (!this.encoded) await this.encode()
-    return this.encoded.toString(encoding)
+  toString(): string {
+    if (!this.encoded) this.encode()
+    return this.encoded.toString()
   }
 
-  /**
-   * @return {String} encoded
-   */
   toHex() {
-    return this.toString('hex')
+    if (!this.encoded) this.encode()
+    return toHex(this.encoded)
   }
 
   /**
    * @return {String} encoded
    */
-  async toBs32() {
-    if (!this.encoded) await this.encode()
-    return bs32.encode(this.encoded)
+  toBs32() {
+    if (!this.encoded) this.encode()
+    return toBase32(this.encoded)
   }
 
   /**
    * @return {String} encoded
    */
-  async toBs58() {
-    if (!this.encoded) await this.encode()
-    return base58.encode(this.encoded)
+  toBs58() {
+    if (!this.encoded) this.encode()
+    return toBase58(this.encoded)
   }
 
   /**

package/src/codec-format-interface.ts

@@ -3,17 +3,26 @@ import Hash from './codec-hash.js'
 import Codec from './codec.js';
 
 export default class FormatInterface extends BasicInterface implements FormatInterface {
-  async init(buffer) {
-    if (buffer instanceof Uint8Array) await this.fromUint8Array(buffer)
-    else if (buffer instanceof ArrayBuffer) await this.fromArrayBuffer(buffer)
+
+  set proto(value) {
+    this._proto = value
+    this.keys = Object.keys(this._proto)
+  }
+
+  get proto() {
+    return this._proto
+  }
+  init(buffer) {
+    if (buffer instanceof Uint8Array) this.fromUint8Array(buffer)
+    else if (buffer instanceof ArrayBuffer) 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}`)
+      if (this.isHex(buffer)) this.fromHex(buffer)
+      else if (this.isBase58(buffer)) this.fromBs58(buffer)
+      else if (this.isBase32(buffer)) this.fromBs32(buffer)
+      else throw new Error(`unsupported ${buffer}`)
     } else {
-      await this.create(buffer)
+      this.create(buffer)
     }
     return this
   }
@@ -24,13 +33,13 @@ export default class FormatInterface extends BasicInterface implements FormatInt
     if (codec.name) return true
   }
 
-  async decode() {
+  decode() {
     let encoded = this.encoded;
     const codec = new Codec(this.encoded)
     if (codec.codecBuffer) {
       encoded = encoded.slice(codec.codecBuffer.length)
       this.name = codec.name
-      this.decoded = await this.protoDecode(encoded)
+      this.decoded = this.protoDecode(encoded)
       try {
         this.decoded = JSON.parse(this.decoded)
       } catch {
@@ -44,13 +53,13 @@ export default class FormatInterface extends BasicInterface implements FormatInt
   }
 
   
-  async encode(decoded?: object | string) {
+  encode(decoded?: object) {
     let encoded: Uint8Array
     if (!decoded) decoded = this.decoded;
     const codec = new Codec(this.name)
 
     if (decoded instanceof Uint8Array) encoded = decoded
-    else encoded = await this.protoEncode(typeof decoded === 'object' ? JSON.stringify(decoded) : decoded)
+    else encoded = this.protoEncode(decoded)
 
     if (codec.codecBuffer) {
       const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length)
@@ -64,7 +73,7 @@ export default class FormatInterface extends BasicInterface implements FormatInt
   }
   /**
    * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
-   * @param {Object} proto - {encode, decode}
+   * @param {Object} proto - {protoObject}
    * @param {Object} options - {hashFormat, name}
    */
   constructor(buffer, proto, options = {}) {
@@ -72,7 +81,7 @@ export default class FormatInterface extends BasicInterface implements FormatInt
     this.proto = proto
     this.hashFormat = options.hashFormat || 'bs32'
     if (options.name) this.name = options.name
-    return this.init(buffer)
+    this.init(buffer)
   }
 
   /**

package/test/index.js

@@ -3,13 +3,12 @@ import {FormatInterface, codecs} from './../dist/index.js'
 
 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'})
+    super(data, {
+      somedata: 'test'
+    } , {name: 'disco-hash'})
   }
 }
 
@@ -17,9 +16,9 @@ const encoded =  [48,  10,   5, 104, 101, 108, 108, 111]
 
 test('format', async  (tape) => {
   tape.plan(2)
-  const message = await new FormatTest({somedata: 'hello'})
+  const message = new FormatTest({somedata: 'hello'})
   
-  const m2 = await new FormatTest(message.encoded)
+  const m2 = new FormatTest(message.encoded)
   
   tape.ok(message.encoded, 'can encode')
   tape.ok(m2.decoded.somedata === 'hello', 'can decode')
@@ -27,7 +26,7 @@ test('format', async  (tape) => {
 
 test('format can hash', async  (tape) => {
   tape.plan(1)
-  const message = await new FormatTest({somedata: 'hello'})
+  const message = new FormatTest({somedata: 'hello'})
   const hash = await message.hash()
   tape.ok(hash, 'can hash')
   

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+      "outDir": "./dist",
+      "esModuleInterop": true,
+      "allowSyntheticDefaultImports": true,
+      "allowJs": true,
+      "target": "es2022",
+      "module": "es2022",
+      "moduleResolution": "nodeNext",
+      "declaration": true
+  },
+  "include": [
+    "./src/**/*"
+  ],
+  "exclude": [
+    "./node_modules/**/*"
+  ]
+}