@polkadot/types-codec 9.5.2 → 9.6.2

package/base/Option.js

@@ -1,13 +1,12 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { isCodec, isNull, isU8a, isUndefined, u8aToHex } from '@polkadot/util';
 import { typeToConstructor } from "../utils/index.js";
 import { Null } from "./Null.js";
-
 function noopSetDefinition(d) {
   return d;
 }
-
 class None extends Null {
   /**
    * @description Returns the base runtime type name for this instance
@@ -15,11 +14,9 @@ class None extends 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)
@@ -31,9 +28,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 (isNull(value) || isUndefined(value) || value === '0x' || value instanceof None) {
     // anyhting empty we pass as-is
@@ -43,9 +40,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
@@ -54,12 +51,9 @@ function decodeOption(registry, Type, value) {
  * implements that - decodes, checks for optionality and wraps the required structure
  * with a value if/as required/found.
  */
-
-
 export class Option {
   #Type;
   #raw;
-
   constructor(registry, typeName, value, {
     definition,
     setDefinition = noopSetDefinition
@@ -69,20 +63,16 @@ export 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, {
@@ -90,82 +80,71 @@ export 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 = []
@@ -175,106 +154,91 @@ export 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' : 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);
   }
-
 }

package/base/Result.js

@@ -1,12 +1,13 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Enum } from "./Enum.js";
+
 /**
  * @name Result
  * @description
  * A Result maps to the Rust Result type, that can either wrap a success or error value
  */
-
 export class Result extends Enum {
   constructor(registry, Ok, Err, value) {
     // NOTE This is order-dependent, Ok (with index 0) needs to be first
@@ -16,72 +17,60 @@ export class Result extends 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}>`;
   }
-
 }

package/base/Tuple.js

@@ -1,44 +1,38 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { isFunction, isHex, isString, isU8a, stringify, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from "../abstract/Array.js";
 import { decodeU8a, mapToTypeMap, typeToConstructor } from "../utils/index.js";
-
 function noopSetDefinition(d) {
   return d;
 }
-/** @internal */
-
 
+/** @internal */
 function decodeTuple(registry, result, value, Classes) {
   if (isU8a(value) || isHex(value)) {
     return decodeU8a(registry, result, 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.
  */
-
-
 export class Tuple extends AbstractArray {
   #Types;
-
   constructor(registry, Types, value, {
     definition,
     setDefinition = noopSetDefinition
@@ -48,12 +42,11 @@ export class Tuple extends AbstractArray {
     this.initialU8aLength = (isU8a(value) ? 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, {
@@ -61,67 +54,57 @@ export class Tuple extends 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 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 u8aConcatStrict(this.toU8aInner(isBare));
   }
-
 }

package/base/UInt.js

@@ -1,6 +1,8 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { AbstractInt } from "../abstract/Int.js";
+
 /**
  * @name UInt
  * @description
@@ -11,19 +13,15 @@ import { AbstractInt } from "../abstract/Int.js";
  * is available here.
  * @noInheritDoc
  */
-
 export class UInt extends AbstractInt {
   static with(bitLength, typeName) {
     return class extends UInt {
       constructor(registry, value) {
         super(registry, value, bitLength);
       }
-
       toRawType() {
         return typeName || super.toRawType();
       }
-
     };
   }
-
 }

package/base/Vec.js

@@ -1,39 +1,32 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { compactFromU8aLim, isU8a, logger, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from "../abstract/Array.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 const MAX_LENGTH = 64 * 1024;
 const l = logger('Vec');
-
 function noopSetDefinition(d) {
   return d;
 }
-
 function decodeVecLength(value) {
   if (Array.isArray(value)) {
     return [value, value.length, 0];
   }
-
   const u8a = u8aToU8a(value);
   const [startAt, length] = compactFromU8aLim(u8a);
-
   if (length > MAX_LENGTH) {
     throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
   }
-
   return [u8a, length, startAt];
 }
-
 export 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) {
@@ -41,12 +34,11 @@ export function decodeVec(registry, result, value, startAt, Type) {
         throw error;
       }
     }
-
     return [0, 0];
   }
-
   return decodeU8aVec(registry, result, u8aToU8a(value), startAt, Type);
 }
+
 /**
  * @name Vec
  * @description
@@ -54,10 +46,8 @@ export 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.
  */
-
 export class Vec extends AbstractArray {
   #Type;
-
   constructor(registry, Type, value = [], {
     definition,
     setDefinition = noopSetDefinition
@@ -67,12 +57,11 @@ export class Vec extends AbstractArray {
     this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
     this.initialU8aLength = (isU8a(decodeFrom) ? 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, {
@@ -80,41 +69,34 @@ export class Vec extends 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()}>`;
   }
-
 }

package/base/VecAny.js

@@ -1,6 +1,8 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { AbstractArray } from "../abstract/Array.js";
+
 /**
  * @name VecAny
  * @description
@@ -8,7 +10,6 @@ import { AbstractArray } from "../abstract/Array.js";
  * a vector, this can be used to manage array-like structures with variable arguments of
  * any types
  */
-
 export class VecAny extends AbstractArray {
   /**
    * @description Returns the base runtime type name for this instance
@@ -17,5 +18,4 @@ export class VecAny extends AbstractArray {
     // FIXME This is basically an any type, cannot instantiate via createType
     return 'Vec<Codec>';
   }
-
 }