@polkadot/types-codec 9.5.1 → 9.6.1

package/cjs/base/Option.js

@@ -4,19 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Option = void 0;
-
 var _util = require("@polkadot/util");
-
 var _utils = require("../utils");
-
 var _Null = require("./Null");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 function noopSetDefinition(d) {
   return d;
 }
-
 class None extends _Null.Null {
   /**
    * @description Returns the base runtime type name for this instance
@@ -24,11 +20,9 @@ class None extends _Null.Null {
   toRawType() {
     return 'None';
   }
-
 }
-/** @internal */
-
 
+/** @internal */
 function decodeOption(registry, Type, value) {
   if (value instanceof Type) {
     // don't re-create, use as it (which also caters for derived types)
@@ -40,9 +34,9 @@ function decodeOption(registry, Type, value) {
     } else if (value.isNone) {
       // internal is None, we are also none
       return new None(registry);
-    } // convert the actual value into known
-
+    }
 
+    // convert the actual value into known
     return new Type(registry, value.value);
   } else if ((0, _util.isNull)(value) || (0, _util.isUndefined)(value) || value === '0x' || value instanceof None) {
     // anyhting empty we pass as-is
@@ -52,9 +46,9 @@ function decodeOption(registry, Type, value) {
     // may be an instance of it, so Type and Option checks go in first
     return !value.length || value[0] === 0 ? new None(registry) : new Type(registry, value.subarray(1));
   }
-
   return new Type(registry, value);
 }
+
 /**
  * @name Option
  * @description
@@ -63,12 +57,9 @@ function decodeOption(registry, Type, value) {
  * implements that - decodes, checks for optionality and wraps the required structure
  * with a value if/as required/found.
  */
-
-
 class Option {
   #Type;
   #raw;
-
   constructor(registry, typeName, value) {
     let {
       definition,
@@ -79,20 +70,16 @@ class Option {
     this.registry = registry;
     this.#Type = Type;
     this.#raw = decoded;
-
     if (decoded && decoded.initialU8aLength) {
       this.initialU8aLength = 1 + decoded.initialU8aLength;
     }
   }
-
   static with(Type) {
     let definition;
-
     const setDefinition = d => {
       definition = d;
       return d;
     };
-
     return class extends Option {
       constructor(registry, value) {
         super(registry, Type, value, {
@@ -100,82 +87,71 @@ class Option {
           setDefinition
         });
       }
-
     };
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     // boolean byte (has value, doesn't have) along with wrapped length
     return 1 + this.#raw.encodedLength;
   }
+
   /**
    * @description returns a hash of the contents
    */
-
-
   get hash() {
     return this.registry.hash(this.toU8a());
   }
+
   /**
    * @description Checks if the Option has no value
    */
-
-
   get isEmpty() {
     return this.isNone;
   }
+
   /**
    * @description Checks if the Option has no value
    */
-
-
   get isNone() {
     return this.#raw instanceof None;
   }
+
   /**
    * @description Checks if the Option has a value
    */
-
-
   get isSome() {
     return !this.isNone;
   }
+
   /**
    * @description The actual value for the Option
    */
-
-
   get value() {
     return this.#raw;
   }
+
   /**
    * @description Compares the value of the input to see if there is a match
    */
-
-
   eq(other) {
     if (other instanceof Option) {
       return this.isSome === other.isSome && this.value.eq(other.value);
     }
-
     return this.value.eq(other);
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     if (this.isNone) {
       return {
         outer: [new Uint8Array([0])]
       };
     }
-
     const {
       inner,
       outer = []
@@ -185,108 +161,92 @@ class Option {
       outer: [new Uint8Array([1]), ...outer]
     };
   }
+
   /**
    * @description Returns a hex string representation of the value
    */
-
-
   toHex() {
     // This attempts to align with the JSON encoding - actually in this case
     // the isSome value is correct, however the `isNone` may be problematic
     return this.isNone ? '0x' : (0, _util.u8aToHex)(this.toU8a().subarray(1));
   }
+
   /**
    * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
    */
-
-
   toHuman(isExtended) {
     return this.#raw.toHuman(isExtended);
   }
+
   /**
    * @description Converts the Object to JSON, typically used for RPC transfers
    */
-
-
   toJSON() {
     return this.isNone ? null : this.#raw.toJSON();
   }
+
   /**
    * @description Converts the value in a best-fit primitive form
    */
-
-
   toPrimitive() {
     return this.isNone ? null : this.#raw.toPrimitive();
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType(isBare) {
     const wrapped = this.registry.getClassName(this.#Type) || new this.#Type(this.registry).toRawType();
     return isBare ? wrapped : `Option<${wrapped}>`;
   }
+
   /**
    * @description Returns the string representation of the value
    */
-
-
   toString() {
     return this.#raw.toString();
   }
+
   /**
    * @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 this.#raw.toU8a(true);
     }
-
     const u8a = new Uint8Array(this.encodedLength);
-
     if (this.isSome) {
       u8a.set([1]);
       u8a.set(this.#raw.toU8a(), 1);
     }
-
     return u8a;
   }
+
   /**
    * @description Returns the value that the Option represents (if available), throws if null
    */
-
-
   unwrap() {
     if (this.isNone) {
       throw new Error('Option: unwrapping a None value');
     }
-
     return this.#raw;
   }
+
   /**
    * @description Returns the value that the Option represents (if available) or defaultValue if none
    * @param defaultValue The value to return if the option isNone
    */
-
-
   unwrapOr(defaultValue) {
     return this.isSome ? this.unwrap() : defaultValue;
   }
+
   /**
    * @description Returns the value that the Option represents (if available) or defaultValue if none
    * @param defaultValue The value to return if the option isNone
    */
-
-
   unwrapOrDefault() {
     return this.isSome ? this.unwrap() : new this.#Type(this.registry);
   }
-
 }
-
 exports.Option = Option;

package/cjs/base/Result.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Result = void 0;
-
 var _Enum = require("./Enum");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -24,74 +22,61 @@ class Result extends _Enum.Enum {
       Err
     }, value);
   }
-
   static with(Types) {
     return class extends Result {
       constructor(registry, value) {
         super(registry, Types.Ok, Types.Err, value);
       }
-
     };
   }
+
   /**
    * @description Returns the wrapper Err value (if isErr)
    */
-
-
   get asErr() {
     if (!this.isErr) {
       throw new Error('Cannot extract Err value from Ok result, check isErr first');
     }
-
     return this.value;
   }
+
   /**
    * @description Returns the wrapper Ok value (if isOk)
    */
-
-
   get asOk() {
     if (!this.isOk) {
       throw new Error('Cannot extract Ok value from Err result, check isOk first');
     }
-
     return this.value;
   }
+
   /**
    * @description Checks if the Result has no value
    */
-
-
   get isEmpty() {
     return this.isOk && this.value.isEmpty;
   }
+
   /**
    * @description Checks if the Result wraps an Err value
    */
-
-
   get isErr() {
     return !this.isOk;
   }
+
   /**
    * @description Checks if the Result wraps an Ok value
    */
-
-
   get isOk() {
     return this.index === 0;
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     const Types = this._toRawStruct();
-
     return `Result<${Types.Ok},${Types.Err}>`;
   }
-
 }
-
 exports.Result = Result;

package/cjs/base/Tuple.js

@@ -4,50 +4,41 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Tuple = void 0;
-
 var _util = require("@polkadot/util");
-
 var _Array = require("../abstract/Array");
-
 var _utils = require("../utils");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 function noopSetDefinition(d) {
   return d;
 }
-/** @internal */
-
 
+/** @internal */
 function decodeTuple(registry, result, value, Classes) {
   if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
     return (0, _utils.decodeU8a)(registry, result, (0, _util.u8aToU8a)(value), Classes);
   }
-
   const Types = Classes[0];
-
   for (let i = 0; i < Types.length; i++) {
     try {
-      const entry = value === null || value === void 0 ? void 0 : value[i];
+      const entry = value == null ? void 0 : value[i];
       result[i] = entry instanceof Types[i] ? entry : new Types[i](registry, entry);
     } catch (error) {
       throw new Error(`Tuple: failed on ${i}:: ${error.message}`);
     }
   }
-
   return [result, 0];
 }
+
 /**
  * @name Tuple
  * @description
  * A Tuple defines an anonymous fixed-length array, where each element has its
  * own type. It extends the base JS `Array` object.
  */
-
-
 class Tuple extends _Array.AbstractArray {
   #Types;
-
   constructor(registry, Types, value) {
     let {
       definition,
@@ -58,12 +49,11 @@ class Tuple extends _Array.AbstractArray {
     this.initialU8aLength = ((0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, this, value, Classes) : decodeTuple(registry, this, value, Classes))[1];
     this.#Types = Classes;
   }
-
   static with(Types) {
-    let definition; // eslint-disable-next-line no-return-assign
+    let definition;
 
+    // eslint-disable-next-line no-return-assign
     const setDefinition = d => definition = d;
-
     return class extends Tuple {
       constructor(registry, value) {
         super(registry, Types, value, {
@@ -71,69 +61,58 @@ class Tuple extends _Array.AbstractArray {
           setDefinition
         });
       }
-
     };
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     let total = 0;
-
     for (let i = 0; i < this.length; i++) {
       total += this[i].encodedLength;
     }
-
     return total;
   }
+
   /**
    * @description The types definition of the tuple
    */
-
-
   get Types() {
     return this.#Types[1].length ? this.#Types[1] : this.#Types[0].map(T => new T(this.registry).toRawType());
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return {
       inner: this.inspectInner()
     };
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     const types = this.#Types[0].map(T => this.registry.getClassName(T) || new T(this.registry).toRawType());
     return `(${types.join(',')})`;
   }
+
   /**
    * @description Returns the string representation of the value
    */
-
-
   toString() {
     // Overwrite the default toString representation of Array.
     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) {
     return (0, _util.u8aConcatStrict)(this.toU8aInner(isBare));
   }
-
 }
-
 exports.Tuple = Tuple;

package/cjs/base/UInt.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.UInt = void 0;
-
 var _Int = require("../abstract/Int");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -26,14 +24,10 @@ class UInt extends _Int.AbstractInt {
       constructor(registry, value) {
         super(registry, value, bitLength);
       }
-
       toRawType() {
         return typeName || super.toRawType();
       }
-
     };
   }
-
 }
-
 exports.UInt = UInt;

package/cjs/base/Vec.js

@@ -5,46 +5,35 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Vec = void 0;
 exports.decodeVec = decodeVec;
-
 var _util = require("@polkadot/util");
-
 var _Array = require("../abstract/Array");
-
 var _utils = require("../utils");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 const MAX_LENGTH = 64 * 1024;
 const l = (0, _util.logger)('Vec');
-
 function noopSetDefinition(d) {
   return d;
 }
-
 function decodeVecLength(value) {
   if (Array.isArray(value)) {
     return [value, value.length, 0];
   }
-
   const u8a = (0, _util.u8aToU8a)(value);
   const [startAt, length] = (0, _util.compactFromU8aLim)(u8a);
-
   if (length > MAX_LENGTH) {
     throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
   }
-
   return [u8a, length, startAt];
 }
-
 function decodeVec(registry, result, value, startAt, Type) {
   if (Array.isArray(value)) {
     const count = result.length;
-
     for (let i = 0; i < count; i++) {
       // 26/08/2022 this is actually a false positive - after recent eslint upgdates
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       const entry = value[i];
-
       try {
         result[i] = entry instanceof Type ? entry : new Type(registry, entry);
       } catch (error) {
@@ -52,12 +41,11 @@ function decodeVec(registry, result, value, startAt, Type) {
         throw error;
       }
     }
-
     return [0, 0];
   }
-
   return (0, _utils.decodeU8aVec)(registry, result, (0, _util.u8aToU8a)(value), startAt, Type);
 }
+
 /**
  * @name Vec
  * @description
@@ -65,11 +53,8 @@ function decodeVec(registry, result, value, startAt, Type) {
  * construction with the passed `Type` in the constructor. It is an extension to Array, providing
  * specific encoding/decoding on top of the base type.
  */
-
-
 class Vec extends _Array.AbstractArray {
   #Type;
-
   constructor(registry, Type) {
     let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
     let {
@@ -81,12 +66,11 @@ class Vec extends _Array.AbstractArray {
     this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
     this.initialU8aLength = ((0, _util.isU8a)(decodeFrom) ? (0, _utils.decodeU8aVec)(registry, this, decodeFrom, startAt, this.#Type) : decodeVec(registry, this, decodeFrom, startAt, this.#Type))[0];
   }
-
   static with(Type) {
-    let definition; // eslint-disable-next-line no-return-assign
+    let definition;
 
+    // eslint-disable-next-line no-return-assign
     const setDefinition = d => definition = d;
-
     return class extends Vec {
       constructor(registry, value) {
         super(registry, Type, value, {
@@ -94,43 +78,35 @@ class Vec extends _Array.AbstractArray {
           setDefinition
         });
       }
-
     };
   }
+
   /**
    * @description The type for the items
    */
-
-
   get Type() {
     return this.#Type.name;
   }
+
   /**
    * @description Finds the index of the value in the array
    */
-
-
   indexOf(_other) {
     // convert type first, this removes overhead from the eq
     const other = _other instanceof this.#Type ? _other : new this.#Type(this.registry, _other);
-
     for (let i = 0; i < this.length; i++) {
       if (other.eq(this[i])) {
         return i;
       }
     }
-
     return -1;
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return `Vec<${this.registry.getClassName(this.#Type) || new this.#Type(this.registry).toRawType()}>`;
   }
-
 }
-
 exports.Vec = Vec;

package/cjs/base/VecAny.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.VecAny = void 0;
-
 var _Array = require("../abstract/Array");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -25,7 +23,5 @@ class VecAny extends _Array.AbstractArray {
     // FIXME This is basically an any type, cannot instantiate via createType
     return 'Vec<Codec>';
   }
-
 }
-
 exports.VecAny = VecAny;