@polkadot/types-codec 9.14.2 → 10.1.1

package/extended/Map.js

@@ -1,44 +1,47 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+var _CodecMap_KeyClass, _CodecMap_ValClass, _CodecMap_type;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 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 +58,142 @@ 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);
-  }
-}
+    constructor(registry, keyType, valType, rawValue, type = 'HashMap') {
+        const [KeyClass, ValClass, decoded, decodedLength] = decodeMap(registry, keyType, valType, rawValue);
+        super(type === 'BTreeMap' ? sortMap(decoded) : decoded);
+        _CodecMap_KeyClass.set(this, void 0);
+        _CodecMap_ValClass.set(this, void 0);
+        _CodecMap_type.set(this, void 0);
+        this.registry = registry;
+        this.initialU8aLength = decodedLength;
+        __classPrivateFieldSet(this, _CodecMap_KeyClass, KeyClass, "f");
+        __classPrivateFieldSet(this, _CodecMap_ValClass, ValClass, "f");
+        __classPrivateFieldSet(this, _CodecMap_type, type, "f");
+    }
+    /**
+     * @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 `${__classPrivateFieldGet(this, _CodecMap_type, "f")}<${this.registry.getClassName(__classPrivateFieldGet(this, _CodecMap_KeyClass, "f")) || new (__classPrivateFieldGet(this, _CodecMap_KeyClass, "f"))(this.registry).toRawType()},${this.registry.getClassName(__classPrivateFieldGet(this, _CodecMap_ValClass, "f")) || new (__classPrivateFieldGet(this, _CodecMap_ValClass, "f"))(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);
+    }
+}
+_CodecMap_KeyClass = new WeakMap(), _CodecMap_ValClass = new WeakMap(), _CodecMap_type = new WeakMap();

package/extended/OptionBool.d.ts

@@ -1,7 +1,7 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyBool, Inspect, Registry } from '../types';
-import { Option } from '../base/Option';
-import { bool as Bool } from '../native/Bool';
+import type { AnyBool, Inspect, Registry } from '../types/index.js';
+import { Option } from '../base/Option.js';
+import { bool as Bool } from '../native/Bool.js';
 /**
  * @name OptionBool
  * @description A specific implementation of Option<bool> than allows for single-byte encoding

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]);
-  }
 }

package/extended/Range.d.ts

@@ -1,5 +1,5 @@
-import type { AnyTuple, CodecClass, INumber, Registry } from '../types';
-import { Tuple } from '../base/Tuple';
+import type { AnyTuple, CodecClass, INumber, Registry } from '../types/index.js';
+import { Tuple } from '../base/Tuple.js';
 type RangeType = 'Range' | 'RangeInclusive';
 interface Options {
     rangeName?: RangeType;

package/extended/Range.js

@@ -1,46 +1,41 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { Tuple } from "../base/Tuple.js";
+var _Range_rangeName;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
+import { Tuple } from '../base/Tuple.js';
 /**
  * @name Range
  * @description
  * Rust `Range<T>` representation
  */
 export class Range extends Tuple {
-  #rangeName;
-  constructor(registry, Type, value, {
-    rangeName = 'Range'
-  } = {}) {
-    super(registry, [Type, Type], value);
-    this.#rangeName = rangeName;
-  }
-  static with(Type) {
-    return class extends Range {
-      constructor(registry, value) {
-        super(registry, Type, value);
-      }
-    };
-  }
-
-  /**
-   * @description Returns the starting range value
-   */
-  get start() {
-    return this[0];
-  }
-
-  /**
-   * @description Returns the ending range value
-   */
-  get end() {
-    return this[1];
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  toRawType() {
-    return `${this.#rangeName}<${this.start.toRawType()}>`;
-  }
-}
+    constructor(registry, Type, value, { rangeName = 'Range' } = {}) {
+        super(registry, [Type, Type], value);
+        _Range_rangeName.set(this, void 0);
+        __classPrivateFieldSet(this, _Range_rangeName, rangeName, "f");
+    }
+    static with(Type) {
+        return class extends Range {
+            constructor(registry, value) {
+                super(registry, Type, value);
+            }
+        };
+    }
+    /**
+     * @description Returns the starting range value
+     */
+    get start() {
+        return this[0];
+    }
+    /**
+     * @description Returns the ending range value
+     */
+    get end() {
+        return this[1];
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return `${__classPrivateFieldGet(this, _Range_rangeName, "f")}<${this.start.toRawType()}>`;
+    }
+}
+_Range_rangeName = new WeakMap();

package/extended/RangeInclusive.d.ts

@@ -1,5 +1,5 @@
-import type { AnyTuple, CodecClass, INumber, Registry } from '../types';
-import { Range } from './Range';
+import type { AnyTuple, CodecClass, INumber, Registry } from '../types/index.js';
+import { Range } from './Range.js';
 export declare class RangeInclusive<T extends INumber = INumber> extends Range<T> {
     constructor(registry: Registry, Type: CodecClass<T> | string, value?: AnyTuple);
     static with<T extends INumber>(Type: CodecClass<T> | string): CodecClass<RangeInclusive<T>>;

package/extended/RangeInclusive.js

@@ -1,18 +1,13 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { Range } from "./Range.js";
+import { Range } from './Range.js';
 export class RangeInclusive extends Range {
-  constructor(registry, Type, value) {
-    super(registry, Type, value, {
-      rangeName: 'RangeInclusive'
-    });
-  }
-  static with(Type) {
-    return class extends RangeInclusive {
-      constructor(registry, value) {
-        super(registry, Type, value);
-      }
-    };
-  }
+    constructor(registry, Type, value) {
+        super(registry, Type, value, { rangeName: 'RangeInclusive' });
+    }
+    static with(Type) {
+        return class extends RangeInclusive {
+            constructor(registry, value) {
+                super(registry, Type, value);
+            }
+        };
+    }
 }