@polkadot/types-codec 9.14.1 → 10.0.1

package/abstract/Array.js

@@ -1,9 +1,5 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { compactToU8a, u8aConcatStrict, u8aToHex } from '@polkadot/util';
-import { compareArray } from "../utils/compareArray.js";
-
+import { compareArray } from '../utils/compareArray.js';
 /**
  * @name AbstractArray
  * @description
@@ -12,154 +8,143 @@ import { compareArray } from "../utils/compareArray.js";
  * @noInheritDoc
  */
 export class AbstractArray extends Array {
-  /**
-   * @description This ensures that operators such as clice, filter, map, etc. return
-   * new Array instances (without this we need to apply overrides)
-   */
-  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 = 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 compareArray(this, other);
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  inspect() {
-    return {
-      inner: this.inspectInner(),
-      outer: [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 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 ? u8aConcatStrict(encoded) : u8aConcatStrict([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;
-  }
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    /**
+     * @description This ensures that operators such as clice, filter, map, etc. return
+     * new Array instances (without this we need to apply overrides)
+     */
+    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 = 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 compareArray(this, other);
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return {
+            inner: this.inspectInner(),
+            outer: [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 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 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
+            ? u8aConcatStrict(encoded)
+            : u8aConcatStrict([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;
+    }
 }

package/abstract/Base.js

@@ -1,118 +1,101 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @name Base
  * @description A type extends the Base class, when it holds a value
  */
 export class AbstractBase {
-  #raw;
-  constructor(registry, value, initialU8aLength) {
-    this.initialU8aLength = initialU8aLength;
-    this.#raw = value;
-    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());
-  }
-
-  /**
-   * @description returns the inner (wrapped value)
-   */
-  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
-   */
-
-  /**
-   * @description Returns the inner wrapped value (equivalent to valueOf)
-   */
-  unwrap() {
-    return this.#raw;
-  }
-
-  /**
-   * @description Returns the inner wrapped value
-   */
-  valueOf() {
-    return this.#raw;
-  }
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    #raw;
+    constructor(registry, value, initialU8aLength) {
+        this.initialU8aLength = initialU8aLength;
+        this.#raw = value;
+        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());
+    }
+    /**
+     * @description returns the inner (wrapped value)
+     */
+    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 inner wrapped value (equivalent to valueOf)
+     */
+    unwrap() {
+        return this.#raw;
+    }
+    /**
+     * @description Returns the inner wrapped value
+     */
+    valueOf() {
+        return this.#raw;
+    }
 }