@polkadot/types-codec 9.5.1 → 9.6.1

package/cjs/extended/HashMap.js

@@ -4,21 +4,17 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.HashMap = void 0;
-
 var _Map = require("./Map");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 class HashMap extends _Map.CodecMap {
   static with(keyType, valType) {
     return class extends HashMap {
       constructor(registry, value) {
         super(registry, keyType, valType, value);
       }
-
     };
   }
-
 }
-
 exports.HashMap = HashMap;

package/cjs/extended/Linkage.js

@@ -4,23 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.LinkageResult = exports.Linkage = void 0;
-
 var _Option = require("../base/Option");
-
 var _Tuple = require("../base/Tuple");
-
 var _Vec = require("../base/Vec");
-
 var _Struct = require("../native/Struct");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 const EMPTY = new Uint8Array();
+
 /**
  * @name Linkage
  * @description The wrapper for the result from a LinkedMap
  */
-
 class Linkage extends _Struct.Struct {
   constructor(registry, Type, value) {
     super(registry, {
@@ -29,51 +25,42 @@ class Linkage extends _Struct.Struct {
       next: _Option.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
  */
-
-
 exports.Linkage = Linkage;
-
 class LinkageResult extends _Tuple.Tuple {
   constructor(registry, _ref, _ref2) {
     let [TypeKey, keys] = _ref;
@@ -83,7 +70,5 @@ class LinkageResult extends _Tuple.Tuple {
       Values: _Vec.Vec.with(TypeValue)
     }, [keys, values]);
   }
-
 }
-
 exports.LinkageResult = LinkageResult;

package/cjs/extended/Map.js

@@ -4,50 +4,37 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.CodecMap = void 0;
-
 var _util = require("@polkadot/util");
-
 var _Array = require("../abstract/Array");
-
 var _Enum = require("../base/Enum");
-
 var _Raw = require("../native/Raw");
-
 var _Struct = require("../native/Struct");
-
 var _utils = require("../utils");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 const l = (0, _util.logger)('Map');
-/** @internal */
 
+/** @internal */
 function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
   const output = new Map();
   const [offset, count] = (0, _util.compactFromU8aLim)(u8a);
   const types = [];
-
   for (let i = 0; i < count; i++) {
     types.push(KeyClass, ValClass);
   }
-
   const [values, decodedLength] = (0, _utils.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 _Array.AbstractArray || KeyClass.prototype instanceof _Struct.Struct || KeyClass.prototype instanceof _Enum.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) {
@@ -55,9 +42,9 @@ function decodeMapFromMap(registry, KeyClass, ValClass, value) {
       throw error;
     }
   }
-
   return [KeyClass, ValClass, output, 0];
 }
+
 /**
  * Decode input to pass into constructor.
  *
@@ -73,12 +60,9 @@ function decodeMapFromMap(registry, KeyClass, ValClass, value) {
  * @param jsonMap
  * @internal
  */
-
-
 function decodeMap(registry, keyType, valType, value) {
   const KeyClass = (0, _utils.typeToConstructor)(registry, keyType);
   const ValClass = (0, _utils.typeToConstructor)(registry, valType);
-
   if (!value) {
     return [KeyClass, ValClass, new Map(), 0];
   } else if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
@@ -88,15 +72,12 @@ function decodeMap(registry, keyType, valType, value) {
   } else if ((0, _util.isObject)(value)) {
     return decodeMapFromMap(registry, KeyClass, ValClass, new Map(Object.entries(value)));
   }
-
   throw new Error('Map: cannot decode type');
 }
-
 class CodecMap extends Map {
   #KeyClass;
   #ValClass;
   #type;
-
   constructor(registry, keyType, valType, rawValue) {
     let type = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'HashMap';
     const [KeyClass, ValClass, decoded, decodedLength] = decodeMap(registry, keyType, valType, rawValue);
@@ -107,148 +88,121 @@ 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 = (0, _util.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 (0, _utils.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: [(0, _util.compactToU8a)(this.size)]
     };
   }
+
   /**
    * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
    */
-
-
   toHex() {
     return (0, _util.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.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.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 (0, _util.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((0, _util.compactToU8a)(this.size));
     }
-
     for (const [k, v] of this.entries()) {
       encoded.push(k.toU8a(isBare), v.toU8a(isBare));
     }
-
     return (0, _util.u8aConcatStrict)(encoded);
   }
-
 }
-
 exports.CodecMap = CodecMap;

package/cjs/extended/OptionBool.js

@@ -4,15 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.OptionBool = void 0;
-
 var _util = require("@polkadot/util");
-
 var _Option = require("../base/Option");
-
 var _Bool = require("../native/Bool");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 function decodeU8a(registry, value) {
   // Encoded as -
   //  - 0 = None
@@ -20,73 +17,63 @@ function decodeU8a(registry, value) {
   //  - 2 = False
   return value[0] === 0 ? null : new _Bool.bool(registry, value[0] === 1);
 }
+
 /**
  * @name OptionBool
  * @description A specific implementation of Option<bool> than allows for single-byte encoding
  */
-
-
 class OptionBool extends _Option.Option {
   constructor(registry, value) {
     super(registry, _Bool.bool, (0, _util.isU8a)(value) || (0, _util.isHex)(value) ? decodeU8a(registry, (0, _util.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]);
   }
-
 }
-
 exports.OptionBool = OptionBool;

package/cjs/extended/Range.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Range = void 0;
-
 var _Tuple = require("../base/Tuple");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -17,7 +15,6 @@ var _Tuple = require("../base/Tuple");
  */
 class Range extends _Tuple.Tuple {
   #rangeName;
-
   constructor(registry, Type, value) {
     let {
       rangeName = 'Range'
@@ -25,40 +22,33 @@ class Range extends _Tuple.Tuple {
     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()}>`;
   }
-
 }
-
 exports.Range = Range;

package/cjs/extended/RangeInclusive.js

@@ -4,27 +4,22 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.RangeInclusive = void 0;
-
 var _Range = require("./Range");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 class RangeInclusive extends _Range.Range {
   constructor(registry, Type, value) {
     super(registry, Type, value, {
       rangeName: 'RangeInclusive'
     });
   }
-
   static with(Type) {
     return class extends RangeInclusive {
       constructor(registry, value) {
         super(registry, Type, value);
       }
-
     };
   }
-
 }
-
 exports.RangeInclusive = RangeInclusive;

package/cjs/extended/Type.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Type = void 0;
-
 var _Text = require("../native/Text");
-
 var _utils = require("../utils");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -25,15 +22,12 @@ class Type extends _Text.Text {
     super(registry, value);
     this.setOverride((0, _utils.sanitize)(this.toString()));
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return 'Type';
   }
-
 }
-
 exports.Type = Type;

package/cjs/extended/U8aFixed.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.U8aFixed = void 0;
-
 var _util = require("@polkadot/util");
-
 var _Raw = require("../native/Raw");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -16,25 +13,21 @@ var _Raw = require("../native/Raw");
 function decodeU8aFixed(value, bitLength) {
   const u8a = (0, _util.u8aToU8a)(value);
   const byteLength = bitLength / 8;
-
   if (!u8a.length) {
     return [new Uint8Array(byteLength), 0];
   }
-
   if ((0, _util.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.
  */
-
-
 class U8aFixed extends _Raw.Raw {
   constructor(registry) {
     let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Uint8Array();
@@ -42,28 +35,22 @@ class U8aFixed extends _Raw.Raw {
     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}]`;
   }
-
 }
-
 exports.U8aFixed = U8aFixed;