@leofcoin/codec-format-interface 1.6.1 → 1.6.2

package/dist/basic-interface.d.ts

@@ -1,20 +1,25 @@
 export default class BasicInterface {
+    #private;
     encoded: Uint8Array;
-    decoded: object | string;
+    decoded: object;
     keys: string[];
     name: string;
+    set proto(value: object);
+    get proto(): object;
+    decode(encoded?: Uint8Array): Object;
+    encode(decoded?: object): Uint8Array;
     protoEncode(data: object): Uint8Array;
     protoDecode(data: Uint8Array): object;
-    isHex(string: any): any;
-    isBase32(string: any): boolean;
-    isBase58(string: any): boolean;
-    fromBs32(encoded: base58String): object;
-    fromBs58(encoded: any): object;
+    isHex(string: string): boolean;
+    isBase32(string: string): boolean;
+    isBase58(string: string): boolean;
+    fromBs32(encoded: string): object;
+    fromBs58(encoded: base58String): object;
     toArray(): Promise<number[]>;
     fromString(string: string): object;
-    fromHex(string: any): any;
+    fromHex(string: string): object;
     fromArray(array: number[]): object;
-    fromEncoded(encoded: Uint8Array): any;
+    fromEncoded(encoded: Uint8Array): Object;
     toString(): string;
     toHex(): string;
     /**
@@ -24,9 +29,9 @@ export default class BasicInterface {
     /**
      * @return {String} encoded
      */
-    toBs58(): string;
+    toBs58(): base58String;
     /**
      * @param {Object} data
      */
-    create(data: object): any;
+    create(data: object): Uint8Array;
 }

package/dist/codec-format-interface.d.ts

@@ -1,18 +1,20 @@
 import BasicInterface from './basic-interface.js';
 import Hash from './codec-hash.js';
 export default class FormatInterface extends BasicInterface implements FormatInterface {
-    set proto(value: any);
-    get proto(): any;
-    init(buffer: any): any;
+    hashFormat: string;
+    init(buffer: Uint8Array | ArrayBuffer | FormatInterface | string): FormatInterface;
     hasCodec(): boolean;
-    decode(): string | object;
+    decode(encoded?: Uint8Array): object;
     encode(decoded?: object): Uint8Array;
     /**
      * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
      * @param {Object} proto - {protoObject}
      * @param {Object} options - {hashFormat, name}
      */
-    constructor(buffer: any, proto: any, options?: {});
+    constructor(buffer: any, proto: any, options?: {
+        hashFormat?: string;
+        name?: string;
+    });
     /**
      * @return {PeernetHash}
      */
@@ -21,6 +23,6 @@ export default class FormatInterface extends BasicInterface implements FormatInt
      * @return {peernetHash}
      */
     hash(): Promise<any>;
-    fromUint8Array(buffer: any): any;
-    fromArrayBuffer(buffer: any): any;
+    fromUint8Array(buffer: any): object;
+    fromArrayBuffer(buffer: any): object;
 }

package/dist/codec-hash.d.ts

@@ -5,20 +5,20 @@ export default class CodecHash extends BasicInterface {
     init(uint8Array: any): Promise<CodecHash>;
     discoCodec: Codec;
     get prefix(): Uint8Array;
-    get length(): any;
+    get length(): number[];
     get buffer(): Uint8Array;
     get hash(): Uint8Array;
     fromJSON(json: any): Promise<Uint8Array>;
     encode(buffer: any, name: any): Promise<Uint8Array>;
     digest: any;
     size: any;
-    codec: any;
+    codec: Uint8Array;
     validate(buffer: any): Promise<void>;
     decode(buffer: any): {
-        codec: any;
+        codec: Uint8Array;
         name: any;
         size: any;
-        length: any;
+        length: number[];
         digest: any;
     };
 }

package/dist/codec.d.ts

@@ -1,13 +1,16 @@
 import BasicInterface from './basic-interface.js';
 export default class Codec extends BasicInterface {
+    codecBuffer: Uint8Array;
+    codec: number;
+    hashAlg: string;
     get codecs(): any;
-    constructor(buffer: any);
-    fromEncoded(encoded: any): void;
-    getCodec(name: any): any;
-    getCodecName(codec: any): string;
-    getHashAlg(name: any): any;
-    fromCodec(codec: any): void;
-    fromName(name: any): void;
-    decode(): void;
-    encode(): Uint8Array;
+    constructor(buffer: string | number | object | Uint8Array | ArrayBuffer);
+    fromEncoded(encoded: Uint8Array): object;
+    getCodec(name: string): number;
+    getCodecName(codec: number): string;
+    getHashAlg(name: string): string;
+    fromCodec(codec: number): void;
+    fromName(name: string): void;
+    decode(encoded?: Uint8Array): object;
+    encode(codec?: number): Uint8Array;
 }

package/dist/index.js

@@ -15,6 +15,22 @@ let BasicInterface$1 = class BasicInterface {
     decoded;
     keys;
     name;
+    #proto;
+    set proto(value) {
+        this.#proto = value;
+        this.keys = Object.keys(value);
+    }
+    get proto() {
+        return this.#proto;
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        return new Object();
+    }
+    encode(decoded) {
+        decoded = decoded || this.decoded;
+        return new Uint8Array();
+    }
     // get Codec(): Codec {}
     protoEncode(data) {
         // check schema
@@ -34,12 +50,10 @@ let BasicInterface$1 = class BasicInterface {
         return base58.isBase58(string);
     }
     fromBs32(encoded) {
-        this.encoded = bs32.decode(encoded);
-        return this.decode();
+        return this.decode(bs32.decode(encoded));
     }
     fromBs58(encoded) {
-        this.encoded = fromBase58(encoded);
-        return this.decode();
+        return this.decode(fromBase58(encoded));
     }
     async toArray() {
         const array = [];
@@ -51,20 +65,16 @@ let BasicInterface$1 = class BasicInterface {
     fromString(string) {
         const array = string.split(',');
         const arrayLike = array.map(string => Number(string));
-        this.encoded = Uint8Array.from(arrayLike);
-        return this.decode();
+        return this.decode(Uint8Array.from(arrayLike));
     }
     fromHex(string) {
-        this.encoded = fromHex(string);
-        return this.decode();
+        return this.decode(fromHex(string));
     }
     fromArray(array) {
-        this.encoded = Uint8Array.from([...array]);
-        return this.decode();
+        return this.decode(Uint8Array.from([...array]));
     }
     fromEncoded(encoded) {
-        this.encoded = encoded;
-        return this.decode();
+        return this.decode(encoded);
     }
     toString() {
         if (!this.encoded)
@@ -74,7 +84,7 @@ let BasicInterface$1 = class BasicInterface {
     toHex() {
         if (!this.encoded)
             this.encode();
-        return toHex(this.encoded);
+        return toHex(this.encoded.toString().split(',').map(number => Number(number)));
     }
     /**
      * @return {String} encoded
@@ -109,7 +119,7 @@ let BasicInterface$1 = class BasicInterface {
                 });
             }
             this.decoded = decoded;
-            return this.encode();
+            return this.encode(decoded);
         }
     }
 };
@@ -208,6 +218,9 @@ var codecs$1 = /*#__PURE__*/Object.freeze({
 });
 
 let Codec$1 = class Codec extends BasicInterface$1 {
+    codecBuffer;
+    codec;
+    hashAlg;
     get codecs() {
         return { ...globalThis.peernet.codecs, ...codecs };
     }
@@ -227,16 +240,17 @@ let Codec$1 = class Codec extends BasicInterface$1 {
                 }
             }
             else if (buffer instanceof ArrayBuffer) {
-                const encoded = new Uint8Array(buffer.byteLength);
-                for (let i = 0; i < buffer.byteLength; i++) {
-                    encoded[i] = buffer[i];
+                const codec = varint.decode(buffer);
+                const name = this.getCodecName(codec);
+                if (name) {
+                    this.name = name;
+                    this.decode(buffer);
+                }
+                else {
+                    this.encode(buffer);
                 }
-                this.encoded = encoded;
-                // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
-                this.decode(buffer);
-                return;
             }
-            if (typeof buffer === 'string') {
+            else if (typeof buffer === 'string') {
                 if (this.codecs[buffer])
                     this.fromName(buffer);
                 else if (this.isHex(buffer))
@@ -258,7 +272,7 @@ let Codec$1 = class Codec extends BasicInterface$1 {
         const name = this.getCodecName(codec);
         this.name = name;
         this.encoded = encoded;
-        this.decode(encoded);
+        return this.decode(encoded);
     }
     getCodec(name) {
         return this.codecs[name].codec;
@@ -288,13 +302,15 @@ let Codec$1 = class Codec extends BasicInterface$1 {
         this.hashAlg = this.getHashAlg(name);
         this.codecBuffer = varint.encode(codec);
     }
-    decode() {
-        const codec = varint.decode(this.encoded);
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        const codec = varint.decode(encoded);
         this.fromCodec(codec);
+        return this.decoded;
     }
-    encode() {
-        const codec = varint.encode(this.decoded);
-        this.encoded = codec;
+    encode(codec) {
+        codec = codec || this.codec;
+        this.encoded = varint.encode(codec);
         return this.encoded;
     }
 };
@@ -325,7 +341,7 @@ let CodecHash$1 = class CodecHash extends BasicInterface$1 {
             }
             if (typeof uint8Array === 'string') {
                 if (this.isHex(uint8Array))
-                    await this.fromHex(uint8Array);
+                    await this.fromHex({ string: uint8Array });
                 if (this.isBase32(uint8Array))
                     await this.fromBs32(uint8Array);
                 else if (this.isBase58(uint8Array))
@@ -398,7 +414,7 @@ let CodecHash$1 = class CodecHash extends BasicInterface$1 {
         }
         if (typeof buffer === 'string') {
             if (this.isHex(buffer))
-                this.fromHex(buffer);
+                this.fromHex({ string: buffer });
             if (this.isBase32(buffer))
                 this.fromBs32(buffer);
         }
@@ -430,19 +446,13 @@ let CodecHash$1 = class CodecHash extends BasicInterface$1 {
 };
 
 let FormatInterface$1 = class FormatInterface extends BasicInterface$1 {
-    set proto(value) {
-        this._proto = value;
-        this.keys = Object.keys(this._proto);
-    }
-    get proto() {
-        return this._proto;
-    }
+    hashFormat;
     init(buffer) {
         if (buffer instanceof Uint8Array)
             this.fromUint8Array(buffer);
         else if (buffer instanceof ArrayBuffer)
             this.fromArrayBuffer(buffer);
-        else if (buffer?.name === this.name)
+        else if (buffer instanceof FormatInterface$1 && buffer?.name === this.name)
             return buffer;
         else if (buffer instanceof String) {
             if (this.isHex(buffer))
@@ -466,18 +476,17 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface$1 {
         if (codec.name)
             return true;
     }
-    decode() {
-        let encoded = this.encoded;
+    decode(encoded) {
+        encoded = encoded || this.encoded;
         const codec = new Codec$1(this.encoded);
         if (codec.codecBuffer) {
             encoded = encoded.slice(codec.codecBuffer.length);
             this.name = codec.name;
             this.decoded = this.protoDecode(encoded);
-            try {
-                this.decoded = JSON.parse(this.decoded);
-            }
-            catch {
-            }
+            // try {
+            //   this.decoded = JSON.parse(this.decoded)
+            // } catch {
+            // }
         }
         else {
             throw new Error(`no codec found`);
@@ -509,11 +518,11 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface$1 {
      * @param {Object} proto - {protoObject}
      * @param {Object} options - {hashFormat, name}
      */
-    constructor(buffer, proto, options = {}) {
+    constructor(buffer, proto, options) {
         super();
         this.proto = proto;
-        this.hashFormat = options.hashFormat || 'bs32';
-        if (options.name)
+        this.hashFormat = options?.hashFormat ? options.hashFormat : 'bs32';
+        if (options?.name)
             this.name = options.name;
         this.init(buffer);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/codec-format-interface",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "",
   "type": "module",
   "exports": {
@@ -38,6 +38,7 @@
     "@rollup/plugin-commonjs": "^23.0.3",
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-typescript": "^10.0.1",
+    "@types/varint": "^6.0.1",
     "rollup": "^3.5.1",
     "tape": "^5.5.3",
     "tslib": "^2.4.1"