@polkadot/types-codec 9.5.2 → 9.6.2

package/extended/Map.js

@@ -1,5 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { compactFromU8aLim, compactToU8a, isHex, isObject, isU8a, logger, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from "../abstract/Array.js";
 import { Enum } from "../base/Enum.js";
@@ -7,34 +8,27 @@ import { Raw } from "../native/Raw.js";
 import { Struct } from "../native/Struct.js";
 import { compareMap, decodeU8a, sortMap, typeToConstructor } from "../utils/index.js";
 const l = logger('Map');
-/** @internal */
 
+/** @internal */
 function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
   const output = new Map();
   const [offset, count] = compactFromU8aLim(u8a);
   const types = [];
-
   for (let i = 0; i < count; i++) {
     types.push(KeyClass, ValClass);
   }
-
   const [values, decodedLength] = decodeU8a(registry, new Array(types.length), u8a.subarray(offset), [types, []]);
-
   for (let i = 0; i < values.length; i += 2) {
     output.set(values[i], values[i + 1]);
   }
-
   return [KeyClass, ValClass, output, offset + decodedLength];
 }
-/** @internal */
-
 
+/** @internal */
 function decodeMapFromMap(registry, KeyClass, ValClass, value) {
   const output = new Map();
-
   for (const [key, val] of value.entries()) {
     const isComplex = KeyClass.prototype instanceof AbstractArray || KeyClass.prototype instanceof Struct || KeyClass.prototype instanceof Enum;
-
     try {
       output.set(key instanceof KeyClass ? key : new KeyClass(registry, isComplex && typeof key === 'string' ? JSON.parse(key) : key), val instanceof ValClass ? val : new ValClass(registry, val));
     } catch (error) {
@@ -42,9 +36,9 @@ function decodeMapFromMap(registry, KeyClass, ValClass, value) {
       throw error;
     }
   }
-
   return [KeyClass, ValClass, output, 0];
 }
+
 /**
  * Decode input to pass into constructor.
  *
@@ -60,12 +54,9 @@ function decodeMapFromMap(registry, KeyClass, ValClass, value) {
  * @param jsonMap
  * @internal
  */
-
-
 function decodeMap(registry, keyType, valType, value) {
   const KeyClass = typeToConstructor(registry, keyType);
   const ValClass = typeToConstructor(registry, valType);
-
   if (!value) {
     return [KeyClass, ValClass, new Map(), 0];
   } else if (isU8a(value) || isHex(value)) {
@@ -75,15 +66,12 @@ function decodeMap(registry, keyType, valType, value) {
   } else if (isObject(value)) {
     return decodeMapFromMap(registry, KeyClass, ValClass, new Map(Object.entries(value)));
   }
-
   throw new Error('Map: cannot decode type');
 }
-
 export class CodecMap extends Map {
   #KeyClass;
   #ValClass;
   #type;
-
   constructor(registry, keyType, valType, rawValue, type = 'HashMap') {
     const [KeyClass, ValClass, decoded, decodedLength] = decodeMap(registry, keyType, valType, rawValue);
     super(type === 'BTreeMap' ? sortMap(decoded) : decoded);
@@ -93,146 +81,120 @@ export class CodecMap extends Map {
     this.#ValClass = ValClass;
     this.#type = type;
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     let len = compactToU8a(this.size).length;
-
     for (const [k, v] of this.entries()) {
       len += k.encodedLength + 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 Compares the value of the input to see if there is a match
    */
-
-
   eq(other) {
     return compareMap(this, other);
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     const inner = new Array();
-
     for (const [k, v] of this.entries()) {
       inner.push(k.inspect());
       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 [k, v] of this.entries()) {
       json[k instanceof Raw && k.isAscii ? k.toUtf8() : k.toString()] = v.toHuman(isExtended);
     }
-
     return json;
   }
+
   /**
    * @description Converts the Object to JSON, typically used for RPC transfers
    */
-
-
   toJSON() {
     const json = {};
-
     for (const [k, v] of this.entries()) {
       json[k.toString()] = v.toJSON();
     }
-
     return json;
   }
+
   /**
    * @description Converts the value in a best-fit primitive form
    */
-
-
   toPrimitive() {
     const json = {};
-
     for (const [k, v] of this.entries()) {
       json[k instanceof Raw && k.isAscii ? k.toUtf8() : k.toString()] = v.toPrimitive();
     }
-
     return json;
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return `${this.#type}<${this.registry.getClassName(this.#KeyClass) || new this.#KeyClass(this.registry).toRawType()},${this.registry.getClassName(this.#ValClass) || new this.#ValClass(this.registry).toRawType()}>`;
   }
+
   /**
    * @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 [k, v] of this.entries()) {
       encoded.push(k.toU8a(isBare), v.toU8a(isBare));
     }
-
     return u8aConcatStrict(encoded);
   }
-
 }

package/extended/OptionBool.js

@@ -1,9 +1,9 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { isHex, isU8a, u8aToU8a } from '@polkadot/util';
 import { Option } from "../base/Option.js";
 import { bool as Bool } from "../native/Bool.js";
-
 function decodeU8a(registry, value) {
   // Encoded as -
   //  - 0 = None
@@ -11,71 +11,62 @@ function decodeU8a(registry, value) {
   //  - 2 = False
   return value[0] === 0 ? null : new Bool(registry, value[0] === 1);
 }
+
 /**
  * @name OptionBool
  * @description A specific implementation of Option<bool> than allows for single-byte encoding
  */
-
-
 export class OptionBool extends Option {
   constructor(registry, value) {
     super(registry, Bool, isU8a(value) || isHex(value) ? decodeU8a(registry, u8aToU8a(value)) : value);
     this.initialU8aLength = 1;
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     return 1;
   }
+
   /**
    * @description Checks if the value is an empty value (always false)
    */
-
-
   get isFalse() {
     return this.isSome ? !this.value.valueOf() : false;
   }
+
   /**
    * @description Checks if the value is an empty value (always false)
    */
-
-
   get isTrue() {
     return this.isSome ? this.value.valueOf() : false;
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return {
       outer: [this.toU8a()]
     };
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType(isBare) {
     return isBare ? 'bool' : 'Option<bool>';
   }
+
   /**
    * @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) {
     if (isBare) {
       return super.toU8a(true);
     }
-
     return this.isSome ? new Uint8Array([this.isTrue ? 1 : 2]) : new Uint8Array([0]);
   }
-
 }

package/extended/Range.js

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { Tuple } from "../base/Tuple.js";
 
+import { Tuple } from "../base/Tuple.js";
 /**
  * @name Range
  * @description
@@ -9,45 +9,38 @@ import { Tuple } from "../base/Tuple.js";
  */
 export class Range extends Tuple {
   #rangeName;
-
   constructor(registry, Type, value, {
     rangeName = 'Range'
   } = {}) {
     super(registry, [Type, Type], value);
     this.#rangeName = rangeName;
   }
-
   static with(Type) {
     return class extends Range {
       constructor(registry, value) {
         super(registry, Type, value);
       }
-
     };
   }
+
   /**
    * @description Returns the starting range value
    */
-
-
   get start() {
     return this[0];
   }
+
   /**
    * @description Returns the ending range value
    */
-
-
   get end() {
     return this[1];
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return `${this.#rangeName}<${this.start.toRawType()}>`;
   }
-
 }

package/extended/RangeInclusive.js

@@ -1,5 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Range } from "./Range.js";
 export class RangeInclusive extends Range {
   constructor(registry, Type, value) {
@@ -7,14 +8,11 @@ export class RangeInclusive extends Range {
       rangeName: 'RangeInclusive'
     });
   }
-
   static with(Type) {
     return class extends RangeInclusive {
       constructor(registry, value) {
         super(registry, Type, value);
       }
-
     };
   }
-
 }

package/extended/Type.js

@@ -1,7 +1,9 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Text } from "../native/Text.js";
 import { sanitize } from "../utils/index.js";
+
 /**
  * @name Type
  * @description
@@ -9,19 +11,16 @@ import { sanitize } from "../utils/index.js";
  * on what Text provides us, however we also adjust the types received from the runtime,
  * i.e. we remove the `T::` prefixes found in some types for consistency across implementation.
  */
-
 export class Type extends Text {
   constructor(registry, value = '') {
     super(registry, value);
     this.setOverride(sanitize(this.toString()));
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return 'Type';
   }
-
 }

package/extended/U8aFixed.js

@@ -1,56 +1,48 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { isU8a, u8aToU8a } from '@polkadot/util';
 import { Raw } from "../native/Raw.js";
-/** @internal */
 
+/** @internal */
 function decodeU8aFixed(value, bitLength) {
   const u8a = u8aToU8a(value);
   const byteLength = bitLength / 8;
-
   if (!u8a.length) {
     return [new Uint8Array(byteLength), 0];
   }
-
   if (isU8a(value) ? u8a.length < byteLength : u8a.length !== byteLength) {
     throw new Error(`Expected input with ${byteLength} bytes (${bitLength} bits), found ${u8a.length} bytes`);
   }
-
   return [u8a.subarray(0, byteLength), byteLength];
 }
+
 /**
  * @name U8aFixed
  * @description
  * A U8a that manages a a sequence of bytes up to the specified bitLength. Not meant
  * to be used directly, rather is should be subclassed with the specific lengths.
  */
-
-
 export class U8aFixed extends Raw {
   constructor(registry, value = new Uint8Array(), bitLength = 256) {
     const [u8a, decodedLength] = decodeU8aFixed(value, bitLength);
     super(registry, u8a, decodedLength);
   }
-
   static with(bitLength, typeName) {
     return class extends U8aFixed {
       constructor(registry, value) {
         super(registry, value, bitLength);
       }
-
       toRawType() {
         return typeName || super.toRawType();
       }
-
     };
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return `[u8;${this.length}]`;
   }
-
 }

package/extended/WrapperKeepOpaque.js

@@ -1,13 +1,12 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { compactAddLength, compactStripLength, compactToU8a, isHex, isU8a, u8aToU8a } from '@polkadot/util';
 import { Raw } from "../native/Raw.js";
 import { typeToConstructor } from "../utils/index.js";
 import { Bytes } from "./Bytes.js";
-
 function decodeRaw(registry, typeName, value) {
   const Type = typeToConstructor(registry, typeName);
-
   if (isU8a(value) || isHex(value)) {
     try {
       const [, u8a] = isHex(value) ? [0, u8aToU8a(value)] : value instanceof Raw ? [0, value.subarray()] : compactStripLength(value);
@@ -16,16 +15,13 @@ function decodeRaw(registry, typeName, value) {
       return [Type, null, value];
     }
   }
-
   const instance = new Type(registry, value);
   return [Type, instance, compactAddLength(instance.toU8a())];
 }
-
 export class WrapperKeepOpaque extends Bytes {
   #Type;
   #decoded;
   #opaqueName;
-
   constructor(registry, typeName, value, {
     opaqueName = 'WrapperKeepOpaque'
   } = {}) {
@@ -35,28 +31,24 @@ export class WrapperKeepOpaque extends Bytes {
     this.#decoded = decoded;
     this.#opaqueName = opaqueName;
   }
-
   static with(Type) {
     return class extends WrapperKeepOpaque {
       constructor(registry, value) {
         super(registry, Type, value);
       }
-
     };
   }
+
   /**
    * @description Checks if the wrapper is decodable
    */
-
-
   get isDecoded() {
     return !!this.#decoded;
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return this.#decoded ? {
       inner: [this.#decoded.inspect()],
@@ -65,49 +57,42 @@ export class WrapperKeepOpaque extends Bytes {
       outer: [compactToU8a(this.length), this.toU8a(true)]
     };
   }
+
   /**
    * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
    */
-
-
   toHuman(isExtended) {
     return this.#decoded ? this.#decoded.toHuman(isExtended) : super.toHuman();
   }
+
   /**
    * @description Converts the value in a best-fit primitive form
    */
-
-
   toPrimitive() {
     return this.#decoded ? this.#decoded.toPrimitive() : super.toPrimitive();
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return `${this.#opaqueName}<${this.registry.getClassName(this.#Type) || (this.#decoded ? this.#decoded.toRawType() : new this.#Type(this.registry).toRawType())}>`;
   }
+
   /**
    * @description Converts the Object to to a string (either decoded or bytes)
    */
-
-
   toString() {
     return this.#decoded ? this.#decoded.toString() : super.toString();
   }
+
   /**
    * @description Returns the decoded that the WrapperKeepOpaque represents (if available), throws if non-decodable
    */
-
-
   unwrap() {
     if (!this.#decoded) {
       throw new Error(`${this.#opaqueName}: unwrapping an undecodable value`);
     }
-
     return this.#decoded;
   }
-
 }

package/extended/WrapperOpaque.js

@@ -1,5 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { WrapperKeepOpaque } from "./WrapperKeepOpaque.js";
 export class WrapperOpaque extends WrapperKeepOpaque {
   constructor(registry, typeName, value) {
@@ -7,22 +8,18 @@ export class WrapperOpaque extends WrapperKeepOpaque {
       opaqueName: 'WrapperOpaque'
     });
   }
-
   static with(Type) {
     return class extends WrapperOpaque {
       constructor(registry, value) {
         super(registry, Type, value);
       }
-
     };
   }
+
   /**
    * @description The inner value for this wrapper, in all cases it _should_ be decodable (unlike KeepOpaque)
    */
-
-
   get inner() {
     return this.unwrap();
   }
-
 }

package/extended/index.js

@@ -1,5 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 export { BitVec } from "./BitVec.js";
 export { BTreeMap } from "./BTreeMap.js";
 export { BTreeSet } from "./BTreeSet.js";

package/index.js

@@ -1,4 +1,5 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import "./detectPackage.js";
 export * from "./bundle.js";