@polkadot/types-codec 9.14.2 → 10.1.1

package/cjs/extended/BTreeSet.js

@@ -1,42 +1,36 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var _BTreeSet_ValClass;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.BTreeSet = void 0;
-var _util = require("@polkadot/util");
-var _utils = require("../utils");
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-const l = (0, _util.logger)('BTreeSet');
-
+const tslib_1 = require("tslib");
+const util_1 = require("@polkadot/util");
+const index_js_1 = require("../utils/index.js");
+const l = (0, util_1.logger)('BTreeSet');
 /** @internal */
 function decodeSetFromU8a(registry, ValClass, u8a) {
-  const output = new Set();
-  const [offset, count] = (0, _util.compactFromU8aLim)(u8a);
-  const result = new Array(count);
-  const [decodedLength] = (0, _utils.decodeU8aVec)(registry, result, u8a, offset, ValClass);
-  for (let i = 0; i < count; i++) {
-    output.add(result[i]);
-  }
-  return [ValClass, output, decodedLength];
+    const output = new Set();
+    const [offset, count] = (0, util_1.compactFromU8aLim)(u8a);
+    const result = new Array(count);
+    const [decodedLength] = (0, index_js_1.decodeU8aVec)(registry, result, u8a, offset, ValClass);
+    for (let i = 0; i < count; i++) {
+        output.add(result[i]);
+    }
+    return [ValClass, output, decodedLength];
 }
-
 /** @internal */
 function decodeSetFromSet(registry, ValClass, value) {
-  const output = new Set();
-  value.forEach(val => {
-    try {
-      output.add(val instanceof ValClass ? val : new ValClass(registry, val));
-    } catch (error) {
-      l.error('Failed to decode key or value:', error.message);
-      throw error;
-    }
-  });
-  return [ValClass, output, 0];
+    const output = new Set();
+    value.forEach((val) => {
+        try {
+            output.add((val instanceof ValClass) ? val : new ValClass(registry, val));
+        }
+        catch (error) {
+            l.error('Failed to decode key or value:', error.message);
+            throw error;
+        }
+    });
+    return [ValClass, output, 0];
 }
-
 /**
  * Decode input to pass into constructor.
  *
@@ -52,153 +46,143 @@ function decodeSetFromSet(registry, ValClass, value) {
  * @internal
  */
 function decodeSet(registry, valType, value) {
-  const ValClass = (0, _utils.typeToConstructor)(registry, valType);
-  if (!value) {
-    return [ValClass, new Set(), 0];
-  } else if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
-    return decodeSetFromU8a(registry, ValClass, (0, _util.u8aToU8a)(value));
-  } else if (Array.isArray(value) || value instanceof Set) {
-    return decodeSetFromSet(registry, ValClass, value);
-  }
-  throw new Error('BTreeSet: cannot decode type');
+    const ValClass = (0, index_js_1.typeToConstructor)(registry, valType);
+    if (!value) {
+        return [ValClass, new Set(), 0];
+    }
+    else if ((0, util_1.isU8a)(value) || (0, util_1.isHex)(value)) {
+        return decodeSetFromU8a(registry, ValClass, (0, util_1.u8aToU8a)(value));
+    }
+    else if (Array.isArray(value) || value instanceof Set) {
+        return decodeSetFromSet(registry, ValClass, value);
+    }
+    throw new Error('BTreeSet: cannot decode type');
 }
 class BTreeSet extends Set {
-  #ValClass;
-  constructor(registry, valType, rawValue) {
-    const [ValClass, values, decodedLength] = decodeSet(registry, valType, rawValue);
-    super((0, _utils.sortSet)(values));
-    this.registry = registry;
-    this.initialU8aLength = decodedLength;
-    this.#ValClass = ValClass;
-  }
-  static with(valType) {
-    return class extends BTreeSet {
-      constructor(registry, value) {
-        super(registry, valType, value);
-      }
-    };
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  get encodedLength() {
-    let len = (0, _util.compactToU8a)(this.size).length;
-    for (const v of this.values()) {
-      len += 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 The actual set values as a string[]
-   */
-  get strings() {
-    return [...super.values()].map(v => v.toString());
-  }
-
-  /**
-   * @description Compares the value of the input to see if there is a match
-   */
-  eq(other) {
-    return (0, _utils.compareSet)(this, other);
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  inspect() {
-    const inner = new Array();
-    for (const v of this.values()) {
-      inner.push(v.inspect());
-    }
-    return {
-      inner,
-      outer: [(0, _util.compactToU8a)(this.size)]
-    };
-  }
-
-  /**
-   * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
-   */
-  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 json = [];
-    for (const v of this.values()) {
-      json.push(v.toHuman(isExtended));
-    }
-    return json;
-  }
-
-  /**
-   * @description Converts the Object to JSON, typically used for RPC transfers
-   */
-  toJSON() {
-    const json = [];
-    for (const v of this.values()) {
-      json.push(v.toJSON());
-    }
-    return json;
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  toRawType() {
-    return `BTreeSet<${this.registry.getClassName(this.#ValClass) || new this.#ValClass(this.registry).toRawType()}>`;
-  }
-
-  /**
-   * @description Converts the value in a best-fit primitive form
-   */
-  toPrimitive() {
-    const json = [];
-    for (const v of this.values()) {
-      json.push(v.toPrimitive());
-    }
-    return json;
-  }
-
-  /**
-   * @description Returns the string representation of the value
-   */
-  toString() {
-    return (0, _util.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((0, _util.compactToU8a)(this.size));
-    }
-    for (const v of this.values()) {
-      encoded.push(v.toU8a(isBare));
-    }
-    return (0, _util.u8aConcatStrict)(encoded);
-  }
+    constructor(registry, valType, rawValue) {
+        const [ValClass, values, decodedLength] = decodeSet(registry, valType, rawValue);
+        super((0, index_js_1.sortSet)(values));
+        _BTreeSet_ValClass.set(this, void 0);
+        this.registry = registry;
+        this.initialU8aLength = decodedLength;
+        tslib_1.__classPrivateFieldSet(this, _BTreeSet_ValClass, ValClass, "f");
+    }
+    static with(valType) {
+        return class extends BTreeSet {
+            constructor(registry, value) {
+                super(registry, valType, value);
+            }
+        };
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        let len = (0, util_1.compactToU8a)(this.size).length;
+        for (const v of this.values()) {
+            len += 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 The actual set values as a string[]
+     */
+    get strings() {
+        return [...super.values()].map((v) => v.toString());
+    }
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other) {
+        return (0, index_js_1.compareSet)(this, other);
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        const inner = new Array();
+        for (const v of this.values()) {
+            inner.push(v.inspect());
+        }
+        return {
+            inner,
+            outer: [(0, util_1.compactToU8a)(this.size)]
+        };
+    }
+    /**
+     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+     */
+    toHex() {
+        return (0, util_1.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 v of this.values()) {
+            json.push(v.toHuman(isExtended));
+        }
+        return json;
+    }
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON() {
+        const json = [];
+        for (const v of this.values()) {
+            json.push(v.toJSON());
+        }
+        return json;
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return `BTreeSet<${this.registry.getClassName(tslib_1.__classPrivateFieldGet(this, _BTreeSet_ValClass, "f")) || new (tslib_1.__classPrivateFieldGet(this, _BTreeSet_ValClass, "f"))(this.registry).toRawType()}>`;
+    }
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive() {
+        const json = [];
+        for (const v of this.values()) {
+            json.push(v.toPrimitive());
+        }
+        return json;
+    }
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString() {
+        return (0, util_1.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((0, util_1.compactToU8a)(this.size));
+        }
+        for (const v of this.values()) {
+            encoded.push(v.toU8a(isBare));
+        }
+        return (0, util_1.u8aConcatStrict)(encoded);
+    }
 }
-exports.BTreeSet = BTreeSet;
+exports.BTreeSet = BTreeSet;
+_BTreeSet_ValClass = new WeakMap();

package/cjs/extended/BitVec.js

@@ -1,92 +1,85 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var _BitVec_decodedLength, _BitVec_isMsb;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.BitVec = void 0;
-var _util = require("@polkadot/util");
-var _Raw = require("../native/Raw");
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+const tslib_1 = require("tslib");
+const util_1 = require("@polkadot/util");
+const Raw_js_1 = require("../native/Raw.js");
 /** @internal */
 function decodeBitVecU8a(value) {
-  if (!value || !value.length) {
-    return [0, new Uint8Array()];
-  }
-
-  // handle all other Uint8Array inputs, these do have a length prefix which is the number of bits encoded
-  const [offset, length] = (0, _util.compactFromU8aLim)(value);
-  const total = offset + Math.ceil(length / 8);
-  if (total > value.length) {
-    throw new Error(`BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
-  }
-  return [length, value.subarray(offset, total)];
+    if (!value || !value.length) {
+        return [0, new Uint8Array()];
+    }
+    // handle all other Uint8Array inputs, these do have a length prefix which is the number of bits encoded
+    const [offset, length] = (0, util_1.compactFromU8aLim)(value);
+    const total = offset + Math.ceil(length / 8);
+    if (total > value.length) {
+        throw new Error(`BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
+    }
+    return [length, value.subarray(offset, total)];
 }
-
 /** @internal */
 function decodeBitVec(value) {
-  if (Array.isArray(value) || (0, _util.isString)(value)) {
-    const u8a = (0, _util.u8aToU8a)(value);
-    return [u8a.length / 8, u8a];
-  }
-  return decodeBitVecU8a(value);
+    if (Array.isArray(value) || (0, util_1.isString)(value)) {
+        const u8a = (0, util_1.u8aToU8a)(value);
+        return [u8a.length / 8, u8a];
+    }
+    return decodeBitVecU8a(value);
 }
-
 /**
  * @name BitVec
  * @description
  * A BitVec that represents an array of bits. The bits are however stored encoded. The difference between this
  * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
  */
-class BitVec extends _Raw.Raw {
-  #decodedLength;
-  #isMsb;
-
-  // In lieu of having the Msb/Lsb identifiers passed through, we default to assuming
-  // we are dealing with Lsb, which is the default (as of writing) BitVec format used
-  // in the Polkadot code (this only affects the toHuman displays)
-  constructor(registry, value) {
-    let isMsb = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    const [decodedLength, u8a] = decodeBitVec(value);
-    super(registry, u8a);
-    this.#decodedLength = decodedLength;
-    this.#isMsb = isMsb;
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  get encodedLength() {
-    return this.length + (0, _util.compactToU8a)(this.#decodedLength).length;
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  inspect() {
-    return {
-      outer: [(0, _util.compactToU8a)(this.#decodedLength), super.toU8a()]
-    };
-  }
-  toHuman() {
-    return `0b${[...this.toU8a(true)].map(d => `00000000${d.toString(2)}`.slice(-8)).map(s => this.#isMsb ? s : s.split('').reverse().join('')).join('_')}`;
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  toRawType() {
-    return 'BitVec';
-  }
-
-  /**
-   * @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 bitVec = super.toU8a();
-    return isBare ? bitVec : (0, _util.u8aConcatStrict)([(0, _util.compactToU8a)(this.#decodedLength), bitVec]);
-  }
+class BitVec extends Raw_js_1.Raw {
+    // In lieu of having the Msb/Lsb identifiers passed through, we default to assuming
+    // we are dealing with Lsb, which is the default (as of writing) BitVec format used
+    // in the Polkadot code (this only affects the toHuman displays)
+    constructor(registry, value, isMsb = false) {
+        const [decodedLength, u8a] = decodeBitVec(value);
+        super(registry, u8a);
+        _BitVec_decodedLength.set(this, void 0);
+        _BitVec_isMsb.set(this, void 0);
+        tslib_1.__classPrivateFieldSet(this, _BitVec_decodedLength, decodedLength, "f");
+        tslib_1.__classPrivateFieldSet(this, _BitVec_isMsb, isMsb, "f");
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        return this.length + (0, util_1.compactToU8a)(tslib_1.__classPrivateFieldGet(this, _BitVec_decodedLength, "f")).length;
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return {
+            outer: [(0, util_1.compactToU8a)(tslib_1.__classPrivateFieldGet(this, _BitVec_decodedLength, "f")), super.toU8a()]
+        };
+    }
+    toHuman() {
+        return `0b${[...this.toU8a(true)]
+            .map((d) => `00000000${d.toString(2)}`.slice(-8))
+            .map((s) => tslib_1.__classPrivateFieldGet(this, _BitVec_isMsb, "f") ? s : s.split('').reverse().join(''))
+            .join('_')}`;
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return 'BitVec';
+    }
+    /**
+     * @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 bitVec = super.toU8a();
+        return isBare
+            ? bitVec
+            : (0, util_1.u8aConcatStrict)([(0, util_1.compactToU8a)(tslib_1.__classPrivateFieldGet(this, _BitVec_decodedLength, "f")), bitVec]);
+    }
 }
-exports.BitVec = BitVec;
+exports.BitVec = BitVec;
+_BitVec_decodedLength = new WeakMap(), _BitVec_isMsb = new WeakMap();