@polkadot/types-codec 9.5.2 → 9.6.2

package/base/VecFixed.js

@@ -1,23 +1,21 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { isU8a, u8aConcatStrict } from '@polkadot/util';
 import { AbstractArray } from "../abstract/Array.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 import { decodeVec } from "./Vec.js";
-
 function noopSetDefinition(d) {
   return d;
 }
+
 /**
  * @name VecFixed
  * @description
  * This manages codec arrays of a fixed length
  */
-
-
 export class VecFixed extends AbstractArray {
   #Type;
-
   constructor(registry, Type, length, value = [], {
     definition,
     setDefinition = noopSetDefinition
@@ -26,12 +24,11 @@ export class VecFixed extends AbstractArray {
     this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
     this.initialU8aLength = (isU8a(value) ? decodeU8aVec(registry, this, value, 0, this.#Type) : decodeVec(registry, this, value, 0, this.#Type))[1];
   }
-
   static with(Type, length) {
-    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 VecFixed {
       constructor(registry, value) {
         super(registry, Type, length, value, {
@@ -39,55 +36,46 @@ export class VecFixed extends AbstractArray {
           setDefinition
         });
       }
-
     };
   }
+
   /**
    * @description The type for the items
    */
-
-
   get Type() {
     return new this.#Type(this.registry).toRawType();
   }
+
   /**
    * @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 Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return {
       inner: this.inspectInner()
     };
   }
-
   toU8a() {
     // we override, we don't add the length prefix for ourselves, and at the same time we
     // ignore isBare on entries, since they should be properly encoded at all times
     const encoded = this.toU8aInner();
     return encoded.length ? u8aConcatStrict(encoded) : new Uint8Array([]);
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return `[${this.Type};${this.length}]`;
   }
-
 }

package/base/index.js

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

package/bundle.js

@@ -1,5 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 export { packageInfo } from "./packageInfo.js";
 export * from "./abstract/index.js";
 export * from "./base/index.js";

package/cjs/abstract/Array.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AbstractArray = void 0;
-
 var _util = require("@polkadot/util");
-
 var _compareArray = require("../utils/compareArray");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -27,179 +24,148 @@ class AbstractArray extends Array {
   static get [Symbol.species]() {
     return Array;
   }
-
   constructor(registry, length) {
     super(length);
     this.registry = registry;
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     // We need to loop through all entries since they may have a variable length themselves,
     // e.g. when a Vec or Compact is contained withing, it has a variable length based on data
     let total = (0, _util.compactToU8a)(this.length).length;
-
     for (let i = 0; i < this.length; i++) {
       total += this[i].encodedLength;
     }
-
     return total;
   }
+
   /**
    * @description returns a hash of the contents
    */
-
-
   get hash() {
     return this.registry.hash(this.toU8a());
   }
+
   /**
    * @description Checks if the value is an empty value
    */
-
-
   get isEmpty() {
     return this.length === 0;
   }
+
   /**
    * @description The length of the value
    */
-
-
   get length() {
     // only included here since we ignore inherited docs
     return super.length;
   }
+
   /**
    * @description Compares the value of the input to see if there is a match
    */
-
-
   eq(other) {
     return (0, _compareArray.compareArray)(this, other);
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return {
       inner: this.inspectInner(),
       outer: [(0, _util.compactToU8a)(this.length)]
     };
   }
-
   inspectInner() {
     const inner = new Array(this.length);
-
     for (let i = 0; i < this.length; i++) {
       inner[i] = this[i].inspect();
     }
-
     return inner;
   }
+
   /**
    * @description Converts the Object to an standard JavaScript Array
    */
-
-
   toArray() {
     return Array.from(this);
   }
+
   /**
    * @description Returns a hex string representation of the value
    */
-
-
   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 result = new Array(this.length);
-
     for (let i = 0; i < this.length; i++) {
       result[i] = this[i] && this[i].toHuman(isExtended);
     }
-
     return result;
   }
+
   /**
    * @description Converts the Object to JSON, typically used for RPC transfers
    */
-
-
   toJSON() {
     const result = new Array(this.length);
-
     for (let i = 0; i < this.length; i++) {
       // We actually log inside the U8a decoding and use JSON.stringify(...), which
       // means that the Vec may be partially populated (same applies to toHuman, same check)
       result[i] = this[i] && this[i].toJSON();
     }
-
     return result;
   }
+
   /**
    * @description Converts the value in a best-fit primitive form
    */
-
-
   toPrimitive() {
     const result = new Array(this.length);
-
     for (let i = 0; i < this.length; i++) {
       result[i] = this[i] && this[i].toPrimitive();
     }
-
     return result;
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
 
-
   /**
    * @description Returns the string representation of the value
    */
   toString() {
     const result = new Array(this.length);
-
     for (let i = 0; i < this.length; i++) {
       result[i] = this[i].toString();
     }
-
     return `[${result.join(', ')}]`;
   }
+
   /**
    * @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 = this.toU8aInner();
     return isBare ? (0, _util.u8aConcatStrict)(encoded) : (0, _util.u8aConcatStrict)([(0, _util.compactToU8a)(this.length), ...encoded]);
   }
-
   toU8aInner(isBare) {
     const encoded = new Array(this.length);
-
     for (let i = 0; i < this.length; i++) {
       encoded[i] = this[i].toU8a(isBare);
     }
-
     return encoded;
   }
-
 }
-
 exports.AbstractArray = AbstractArray;

package/cjs/abstract/Base.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AbstractBase = void 0;
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -14,118 +13,101 @@ exports.AbstractBase = void 0;
  */
 class AbstractBase {
   #raw;
-
   constructor(registry, value, initialU8aLength) {
     this.#raw = value;
     this.initialU8aLength = initialU8aLength;
     this.registry = registry;
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     return this.toU8a().length;
   }
+
   /**
    * @description returns a hash of the contents
    */
-
-
   get hash() {
     return this.registry.hash(this.toU8a());
   }
-
   get inner() {
     return this.#raw;
   }
+
   /**
    * @description Checks if the value is an empty value
    */
-
-
   get isEmpty() {
     return this.#raw.isEmpty;
   }
+
   /**
    * @description Compares the value of the input to see if there is a match
    */
-
-
   eq(other) {
     return this.#raw.eq(other);
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return this.#raw.inspect();
   }
+
   /**
    * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
    */
-
-
   toHex(isLe) {
     return this.#raw.toHex(isLe);
   }
+
   /**
    * @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.#raw.toJSON();
   }
+
   /**
    * @description Converts the value in a best-fit primitive form
    */
-
-
   toPrimitive() {
     return this.#raw.toPrimitive();
   }
+
   /**
    * @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) {
     return this.#raw.toU8a(isBare);
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return 'Base';
   }
-
   unwrap() {
     return this.#raw;
   }
-
 }
-
 exports.AbstractBase = AbstractBase;

package/cjs/abstract/BigInt.js

@@ -4,11 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AbstractBigInt = void 0;
-
 var _xBigint = require("@polkadot/x-bigint");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 // @ts-expect-error not extensible, we make it extensible here
 class AbstractBigInt extends _xBigint.BigInt {
   // @ts-expect-error super() not required, the self magic does that
@@ -17,7 +16,5 @@ class AbstractBigInt extends _xBigint.BigInt {
     Object.setPrototypeOf(self, AbstractBigInt.prototype);
     return self;
   }
-
 }
-
 exports.AbstractBigInt = AbstractBigInt;