@polkadot/types-codec 9.14.1 → 10.0.1

package/extended/HashMap.js

@@ -1,13 +1,10 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { CodecMap } from "./Map.js";
+import { CodecMap } from './Map.js';
 export class HashMap extends CodecMap {
-  static with(keyType, valType) {
-    return class extends HashMap {
-      constructor(registry, value) {
-        super(registry, keyType, valType, value);
-      }
-    };
-  }
+    static with(keyType, valType) {
+        return class extends HashMap {
+            constructor(registry, value) {
+                super(registry, keyType, valType, value);
+            }
+        };
+    }
 }

package/extended/Linkage.js

@@ -1,64 +1,59 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { Option } from "../base/Option.js";
-import { Tuple } from "../base/Tuple.js";
-import { Vec } from "../base/Vec.js";
-import { Struct } from "../native/Struct.js";
+import { Option } from '../base/Option.js';
+import { Tuple } from '../base/Tuple.js';
+import { Vec } from '../base/Vec.js';
+import { Struct } from '../native/Struct.js';
 const EMPTY = new Uint8Array();
-
 /**
  * @name Linkage
  * @description The wrapper for the result from a LinkedMap
  */
 export class Linkage extends Struct {
-  constructor(registry, Type, value) {
-    super(registry, {
-      previous: Option.with(Type),
-      // eslint-disable-next-line sort-keys
-      next: 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();
-  }
+    constructor(registry, Type, value) {
+        super(registry, {
+            previous: Option.with(Type),
+            // eslint-disable-next-line sort-keys
+            next: 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
  */
 export class LinkageResult extends Tuple {
-  constructor(registry, [TypeKey, keys], [TypeValue, values]) {
-    super(registry, {
-      Keys: Vec.with(TypeKey),
-      Values: Vec.with(TypeValue)
-    }, [keys, values]);
-  }
+    constructor(registry, [TypeKey, keys], [TypeValue, values]) {
+        super(registry, {
+            Keys: Vec.with(TypeKey),
+            Values: Vec.with(TypeValue)
+        }, [keys, values]);
+    }
 }

package/extended/Map.js

@@ -1,44 +1,45 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { compactFromU8aLim, compactToU8a, isHex, isObject, isU8a, logger, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
-import { AbstractArray } from "../abstract/Array.js";
-import { Enum } from "../base/Enum.js";
-import { Raw } from "../native/Raw.js";
-import { Struct } from "../native/Struct.js";
-import { compareMap, decodeU8a, sortMap, typeToConstructor } from "../utils/index.js";
+import { AbstractArray } from '../abstract/Array.js';
+import { Enum } from '../base/Enum.js';
+import { Raw } from '../native/Raw.js';
+import { Struct } from '../native/Struct.js';
+import { compareMap, decodeU8a, sortMap, typeToConstructor } from '../utils/index.js';
 const l = logger('Map');
-
 /** @internal */
 function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
-  const output = new Map();
-  const [offset, count] = compactFromU8aLim(u8a);
-  const types = [];
-  for (let i = 0; i < count; i++) {
-    types.push(KeyClass, ValClass);
-  }
-  const [values, decodedLength] = 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];
+    const output = new Map();
+    const [offset, count] = compactFromU8aLim(u8a);
+    const types = [];
+    for (let i = 0; i < count; i++) {
+        types.push(KeyClass, ValClass);
+    }
+    const [values, decodedLength] = 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 */
 function decodeMapFromMap(registry, KeyClass, ValClass, value) {
-  const output = new Map();
-  for (const [key, val] of value.entries()) {
-    const isComplex = KeyClass.prototype instanceof AbstractArray || KeyClass.prototype instanceof Struct || KeyClass.prototype instanceof 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) {
-      l.error('Failed to decode key or value:', error.message);
-      throw error;
-    }
-  }
-  return [KeyClass, ValClass, output, 0];
+    const output = new Map();
+    for (const [key, val] of value.entries()) {
+        const isComplex = KeyClass.prototype instanceof AbstractArray ||
+            KeyClass.prototype instanceof Struct ||
+            KeyClass.prototype instanceof 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) {
+            l.error('Failed to decode key or value:', error.message);
+            throw error;
+        }
+    }
+    return [KeyClass, ValClass, output, 0];
 }
-
 /**
  * Decode input to pass into constructor.
  *
@@ -55,146 +56,145 @@ function decodeMapFromMap(registry, KeyClass, ValClass, value) {
  * @internal
  */
 function decodeMap(registry, keyType, valType, value) {
-  const KeyClass = typeToConstructor(registry, keyType);
-  const ValClass = typeToConstructor(registry, valType);
-  if (!value) {
-    return [KeyClass, ValClass, new Map(), 0];
-  } else if (isU8a(value) || isHex(value)) {
-    return decodeMapFromU8a(registry, KeyClass, ValClass, u8aToU8a(value));
-  } else if (value instanceof Map) {
-    return decodeMapFromMap(registry, KeyClass, ValClass, value);
-  } else if (isObject(value)) {
-    return decodeMapFromMap(registry, KeyClass, ValClass, new Map(Object.entries(value)));
-  }
-  throw new Error('Map: cannot decode type');
+    const KeyClass = typeToConstructor(registry, keyType);
+    const ValClass = typeToConstructor(registry, valType);
+    if (!value) {
+        return [KeyClass, ValClass, new Map(), 0];
+    }
+    else if (isU8a(value) || isHex(value)) {
+        return decodeMapFromU8a(registry, KeyClass, ValClass, u8aToU8a(value));
+    }
+    else if (value instanceof Map) {
+        return decodeMapFromMap(registry, KeyClass, ValClass, value);
+    }
+    else if (isObject(value)) {
+        return decodeMapFromMap(registry, KeyClass, ValClass, new Map(Object.entries(value)));
+    }
+    throw new Error('Map: cannot decode type');
 }
 export class CodecMap extends Map {
-  #KeyClass;
-  #ValClass;
-  #type;
-  constructor(registry, keyType, valType, rawValue, type = 'HashMap') {
-    const [KeyClass, ValClass, decoded, decodedLength] = decodeMap(registry, keyType, valType, rawValue);
-    super(type === 'BTreeMap' ? sortMap(decoded) : decoded);
-    this.registry = registry;
-    this.initialU8aLength = decodedLength;
-    this.#KeyClass = KeyClass;
-    this.#ValClass = ValClass;
-    this.#type = type;
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  get encodedLength() {
-    let len = 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 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: [compactToU8a(this.size)]
-    };
-  }
-
-  /**
-   * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
-   */
-  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 json = {};
-    for (const [k, v] of this.entries()) {
-      json[k instanceof 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 && 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 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(compactToU8a(this.size));
-    }
-    for (const [k, v] of this.entries()) {
-      encoded.push(k.toU8a(isBare), v.toU8a(isBare));
-    }
-    return u8aConcatStrict(encoded);
-  }
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    #KeyClass;
+    #ValClass;
+    #type;
+    constructor(registry, keyType, valType, rawValue, type = 'HashMap') {
+        const [KeyClass, ValClass, decoded, decodedLength] = decodeMap(registry, keyType, valType, rawValue);
+        super(type === 'BTreeMap' ? sortMap(decoded) : decoded);
+        this.registry = registry;
+        this.initialU8aLength = decodedLength;
+        this.#KeyClass = KeyClass;
+        this.#ValClass = ValClass;
+        this.#type = type;
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        let len = 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 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: [compactToU8a(this.size)]
+        };
+    }
+    /**
+     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+     */
+    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 json = {};
+        for (const [k, v] of this.entries()) {
+            json[k instanceof 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 && 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 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(compactToU8a(this.size));
+        }
+        for (const [k, v] of this.entries()) {
+            encoded.push(k.toU8a(isBare), v.toU8a(isBare));
+        }
+        return u8aConcatStrict(encoded);
+    }
 }

package/extended/OptionBool.js

@@ -1,72 +1,72 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { isHex, isU8a, u8aToU8a } from '@polkadot/util';
-import { Option } from "../base/Option.js";
-import { bool as Bool } from "../native/Bool.js";
+import { Option } from '../base/Option.js';
+import { bool as Bool } from '../native/Bool.js';
 function decodeU8a(registry, value) {
-  // Encoded as -
-  //  - 0 = None
-  //  - 1 = True
-  //  - 2 = False
-  return value[0] === 0 ? null : new Bool(registry, value[0] === 1);
+    // Encoded as -
+    //  - 0 = None
+    //  - 1 = True
+    //  - 2 = False
+    return value[0] === 0
+        ? null
+        : new Bool(registry, value[0] === 1);
 }
-
 /**
  * @name OptionBool
  * @description A specific implementation of Option<bool> than allows for single-byte encoding
  */
 export class OptionBool extends Option {
-  constructor(registry, value) {
-    super(registry, Bool, isU8a(value) || isHex(value) ? decodeU8a(registry, 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);
+    constructor(registry, value) {
+        super(registry, Bool, isU8a(value) || isHex(value)
+            ? decodeU8a(registry, 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]);
     }
-    return this.isSome ? new Uint8Array([this.isTrue ? 1 : 2]) : new Uint8Array([0]);
-  }
 }