@polkadot/types-codec 9.5.2 → 9.6.2

package/extended/BTreeSet.js

@@ -1,25 +1,23 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { compactFromU8aLim, compactToU8a, isHex, isU8a, logger, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { compareSet, decodeU8aVec, sortSet, typeToConstructor } from "../utils/index.js";
 const l = logger('BTreeSet');
-/** @internal */
 
+/** @internal */
 function decodeSetFromU8a(registry, ValClass, u8a) {
   const output = new Set();
   const [offset, count] = compactFromU8aLim(u8a);
   const result = new Array(count);
   const [decodedLength] = decodeU8aVec(registry, result, u8a, offset, ValClass);
-
   for (let i = 0; i < count; i++) {
     output.add(result[i]);
   }
-
   return [ValClass, output, decodedLength];
 }
-/** @internal */
-
 
+/** @internal */
 function decodeSetFromSet(registry, ValClass, value) {
   const output = new Set();
   value.forEach(val => {
@@ -32,6 +30,7 @@ function decodeSetFromSet(registry, ValClass, value) {
   });
   return [ValClass, output, 0];
 }
+
 /**
  * Decode input to pass into constructor.
  *
@@ -46,11 +45,8 @@ function decodeSetFromSet(registry, ValClass, value) {
  * @param jsonSet
  * @internal
  */
-
-
 function decodeSet(registry, valType, value) {
   const ValClass = typeToConstructor(registry, valType);
-
   if (!value) {
     return [ValClass, new Set(), 0];
   } else if (isU8a(value) || isHex(value)) {
@@ -58,13 +54,10 @@ function decodeSet(registry, valType, value) {
   } else if (Array.isArray(value) || value instanceof Set) {
     return decodeSetFromSet(registry, ValClass, value);
   }
-
   throw new Error('BTreeSet: cannot decode type');
 }
-
 export class BTreeSet extends Set {
   #ValClass;
-
   constructor(registry, valType, rawValue) {
     const [ValClass, values, decodedLength] = decodeSet(registry, valType, rawValue);
     super(sortSet(values));
@@ -72,162 +65,133 @@ export class BTreeSet extends Set {
     this.initialU8aLength = decodedLength;
     this.#ValClass = ValClass;
   }
-
   static with(valType) {
     return class extends BTreeSet {
       constructor(registry, value) {
         super(registry, valType, value);
       }
-
     };
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     let len = compactToU8a(this.size).length;
-
     for (const v of this.values()) {
       len += v.encodedLength;
     }
-
     return len;
   }
+
   /**
    * @description Returns a hash of the value
    */
-
-
   get hash() {
     return this.registry.hash(this.toU8a());
   }
+
   /**
    * @description Checks if the value is an empty value
    */
-
-
   get isEmpty() {
     return this.size === 0;
   }
+
   /**
    * @description The actual set values as a string[]
    */
-
-
   get strings() {
     return [...super.values()].map(v => v.toString());
   }
+
   /**
    * @description Compares the value of the input to see if there is a match
    */
-
-
   eq(other) {
     return compareSet(this, other);
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     const inner = new Array();
-
     for (const v of this.values()) {
       inner.push(v.inspect());
     }
-
     return {
       inner,
       outer: [compactToU8a(this.size)]
     };
   }
+
   /**
    * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
    */
-
-
   toHex() {
     return u8aToHex(this.toU8a());
   }
+
   /**
    * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
    */
-
-
   toHuman(isExtended) {
     const json = [];
-
     for (const v of this.values()) {
       json.push(v.toHuman(isExtended));
     }
-
     return json;
   }
+
   /**
    * @description Converts the Object to JSON, typically used for RPC transfers
    */
-
-
   toJSON() {
     const json = [];
-
     for (const v of this.values()) {
       json.push(v.toJSON());
     }
-
     return json;
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return `BTreeSet<${this.registry.getClassName(this.#ValClass) || new this.#ValClass(this.registry).toRawType()}>`;
   }
+
   /**
    * @description Converts the value in a best-fit primitive form
    */
-
-
   toPrimitive() {
     const json = [];
-
     for (const v of this.values()) {
       json.push(v.toPrimitive());
     }
-
     return json;
   }
+
   /**
    * @description Returns the string representation of the value
    */
-
-
   toString() {
     return stringify(this.toJSON());
   }
+
   /**
    * @description Encodes the value as a Uint8Array as per the SCALE specifications
    * @param isBare true when the value has none of the type-specific prefixes (internal)
    */
-
-
   toU8a(isBare) {
     const encoded = new Array();
-
     if (!isBare) {
       encoded.push(compactToU8a(this.size));
     }
-
     for (const v of this.values()) {
       encoded.push(v.toU8a(isBare));
     }
-
     return u8aConcatStrict(encoded);
   }
-
 }

package/extended/BitVec.js

@@ -1,94 +1,85 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { compactFromU8aLim, compactToU8a, isString, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
 import { Raw } from "../native/Raw.js";
-/** @internal */
 
+/** @internal */
 function decodeBitVecU8a(value) {
   if (!value || !value.length) {
     return [0, new Uint8Array()];
-  } // handle all other Uint8Array inputs, these do have a length prefix which is the number of bits encoded
-
+  }
 
+  // handle all other Uint8Array inputs, these do have a length prefix which is the number of bits encoded
   const [offset, length] = compactFromU8aLim(value);
   const total = offset + Math.ceil(length / 8);
-
   if (total > value.length) {
     throw new Error(`BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
   }
-
   return [length, value.subarray(offset, total)];
 }
-/** @internal */
-
 
+/** @internal */
 function decodeBitVec(value) {
   if (Array.isArray(value) || isString(value)) {
     const u8a = u8aToU8a(value);
     return [u8a.length / 8, u8a];
   }
-
   return decodeBitVecU8a(value);
 }
+
 /**
  * @name BitVec
  * @description
  * A BitVec that represents an array of bits. The bits are however stored encoded. The difference between this
  * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
  */
-
-
 export class BitVec extends Raw {
   #decodedLength;
-  #isMsb; // In lieu of having the Msb/Lsb identifiers passed through, we default to assuming
+  #isMsb;
+
+  // In lieu of having the Msb/Lsb identifiers passed through, we default to assuming
   // we are dealing with Lsb, which is the default (as of writing) BitVec format used
   // in the Polkadot code (this only affects the toHuman displays)
-
   constructor(registry, value, isMsb = false) {
     const [decodedLength, u8a] = decodeBitVec(value);
     super(registry, u8a);
     this.#decodedLength = decodedLength;
     this.#isMsb = isMsb;
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     return this.length + compactToU8a(this.#decodedLength).length;
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return {
       outer: [compactToU8a(this.#decodedLength), super.toU8a()]
     };
   }
-
   toHuman() {
     return `0b${[...this.toU8a(true)].map(d => `00000000${d.toString(2)}`.slice(-8)).map(s => this.#isMsb ? s : s.split('').reverse().join('')).join('_')}`;
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return 'BitVec';
   }
+
   /**
    * @description Encodes the value as a Uint8Array as per the SCALE specifications
    * @param isBare true when the value has none of the type-specific prefixes (internal)
    */
-
-
   toU8a(isBare) {
     const bitVec = super.toU8a();
     return isBare ? bitVec : u8aConcatStrict([compactToU8a(this.#decodedLength), bitVec]);
   }
-
 }

package/extended/Bytes.js

@@ -1,28 +1,29 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { compactAddLength, compactFromU8aLim, compactToU8a, isString, isU8a, u8aToU8a } from '@polkadot/util';
-import { Raw } from "../native/Raw.js"; // Bytes are used for things like on-chain code, so it has a healthy limit
+import { Raw } from "../native/Raw.js";
 
+// Bytes are used for things like on-chain code, so it has a healthy limit
 const MAX_LENGTH = 10 * 1024 * 1024;
-/** @internal */
 
+/** @internal */
 function decodeBytesU8a(value) {
   if (!value.length) {
     return [new Uint8Array(), 0];
-  } // handle all other Uint8Array inputs, these do have a length prefix
-
+  }
 
+  // handle all other Uint8Array inputs, these do have a length prefix
   const [offset, length] = compactFromU8aLim(value);
   const total = offset + length;
-
   if (length > MAX_LENGTH) {
     throw new Error(`Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
   } else if (total > value.length) {
     throw new Error(`Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
   }
-
   return [value.subarray(offset, total), total];
 }
+
 /**
  * @name Bytes
  * @description
@@ -30,48 +31,41 @@ function decodeBytesU8a(value) {
  * is that this version allows for length-encoding. (i.e. it is a variable-item codec, the same
  * as what is found in [[Text]] and [[Vec]])
  */
-
-
 export class Bytes extends Raw {
   constructor(registry, value) {
     const [u8a, decodedLength] = isU8a(value) && !(value instanceof Raw) ? decodeBytesU8a(value) : Array.isArray(value) || isString(value) ? [u8aToU8a(value), 0] : [value, 0];
     super(registry, u8a, decodedLength);
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     return this.length + compactToU8a(this.length).length;
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect(isBare) {
     const clength = compactToU8a(this.length);
     return {
       outer: isBare ? [super.toU8a()] : this.length ? [clength, super.toU8a()] : [clength]
     };
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return 'Bytes';
   }
+
   /**
    * @description Encodes the value as a Uint8Array as per the SCALE specifications
    * @param isBare true when the value has none of the type-specific prefixes (internal)
    */
-
-
   toU8a(isBare) {
     return isBare ? super.toU8a(isBare) : compactAddLength(this);
   }
-
 }

package/extended/HashMap.js

@@ -1,5 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { CodecMap } from "./Map.js";
 export class HashMap extends CodecMap {
   static with(keyType, valType) {
@@ -7,8 +8,6 @@ export class HashMap extends CodecMap {
       constructor(registry, value) {
         super(registry, keyType, valType, value);
       }
-
     };
   }
-
 }

package/extended/Linkage.js

@@ -1,15 +1,16 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Option } from "../base/Option.js";
 import { Tuple } from "../base/Tuple.js";
 import { Vec } from "../base/Vec.js";
 import { Struct } from "../native/Struct.js";
 const EMPTY = new Uint8Array();
+
 /**
  * @name Linkage
  * @description The wrapper for the result from a LinkedMap
  */
-
 export class Linkage extends Struct {
   constructor(registry, Type, value) {
     super(registry, {
@@ -18,48 +19,41 @@ export class Linkage extends Struct {
       next: Option.with(Type)
     }, value);
   }
-
   static withKey(Type) {
     return class extends Linkage {
       constructor(registry, value) {
         super(registry, Type, value);
       }
-
     };
   }
-
   get previous() {
     return this.get('previous');
   }
-
   get next() {
     return this.get('next');
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return `Linkage<${this.next.toRawType(true)}>`;
   }
+
   /**
    * @description Custom toU8a which with bare mode does not return the linkage if empty
    */
-
-
   toU8a() {
     // As part of a storage query (where these appear), in the case of empty, the values
     // are NOT populated by the node - follow the same logic, leaving it empty
     return this.isEmpty ? EMPTY : super.toU8a();
   }
-
 }
+
 /**
  * @name LinkageResult
  * @description A Linkage keys/Values tuple
  */
-
 export class LinkageResult extends Tuple {
   constructor(registry, [TypeKey, keys], [TypeValue, values]) {
     super(registry, {
@@ -67,5 +61,4 @@ export class LinkageResult extends Tuple {
       Values: Vec.with(TypeValue)
     }, [keys, values]);
   }
-
 }