@polkadot/types-codec 16.2.1 → 16.3.1

package/cjs/base/Enum.js

@@ -130,12 +130,12 @@ class Enum {
     createdAtHash;
     initialU8aLength;
     isStorageFallback;
-    __internal__def;
-    __internal__entryIndex;
-    __internal__indexes;
-    __internal__isBasic;
-    __internal__isIndexed;
-    __internal__raw;
+    #def;
+    #entryIndex;
+    #indexes;
+    #isBasic;
+    #isIndexed;
+    #raw;
     constructor(registry, Types, value, index, { definition, setDefinition = util_1.identity } = {}) {
         const { def, isBasic, isIndexed } = definition || setDefinition(extractDef(registry, Types));
         // shortcut isU8a as used in SCALE decoding
@@ -143,14 +143,14 @@ class Enum {
             ? createFromU8a(registry, def, value[0], value.subarray(1))
             : decodeEnum(registry, def, value, index);
         this.registry = registry;
-        this.__internal__def = def;
-        this.__internal__isBasic = isBasic;
-        this.__internal__isIndexed = isIndexed;
-        this.__internal__indexes = Object.values(def).map(({ index }) => index);
-        this.__internal__entryIndex = this.__internal__indexes.indexOf(decoded.index);
-        this.__internal__raw = decoded.value;
-        if (this.__internal__raw.initialU8aLength) {
-            this.initialU8aLength = 1 + this.__internal__raw.initialU8aLength;
+        this.#def = def;
+        this.#isBasic = isBasic;
+        this.#isIndexed = isIndexed;
+        this.#indexes = Object.values(def).map(({ index }) => index);
+        this.#entryIndex = this.#indexes.indexOf(decoded.index);
+        this.#raw = decoded.value;
+        if (this.#raw.initialU8aLength) {
+            this.initialU8aLength = 1 + this.#raw.initialU8aLength;
         }
     }
     static with(Types) {
@@ -187,7 +187,7 @@ class Enum {
      * @description The length of the value when encoded as a Uint8Array
      */
     get encodedLength() {
-        return 1 + this.__internal__raw.encodedLength;
+        return 1 + this.#raw.encodedLength;
     }
     /**
      * @description returns a hash of the contents
@@ -199,55 +199,55 @@ class Enum {
      * @description The index of the enum value
      */
     get index() {
-        return this.__internal__indexes[this.__internal__entryIndex];
+        return this.#indexes[this.#entryIndex];
     }
     /**
      * @description The value of the enum
      */
     get inner() {
-        return this.__internal__raw;
+        return this.#raw;
     }
     /**
      * @description true if this is a basic enum (no values)
      */
     get isBasic() {
-        return this.__internal__isBasic;
+        return this.#isBasic;
     }
     /**
      * @description Checks if the value is an empty value
      */
     get isEmpty() {
-        return this.__internal__raw.isEmpty;
+        return this.#raw.isEmpty;
     }
     /**
      * @description Checks if the Enum points to a [[Null]] type
      */
     get isNone() {
-        return this.__internal__raw instanceof Null_js_1.Null;
+        return this.#raw instanceof Null_js_1.Null;
     }
     /**
      * @description The available keys for this enum
      */
     get defIndexes() {
-        return this.__internal__indexes;
+        return this.#indexes;
     }
     /**
      * @description The available keys for this enum
      */
     get defKeys() {
-        return Object.keys(this.__internal__def);
+        return Object.keys(this.#def);
     }
     /**
      * @description The name of the type this enum value represents
      */
     get type() {
-        return this.defKeys[this.__internal__entryIndex];
+        return this.defKeys[this.#entryIndex];
     }
     /**
      * @description The value of the enum
      */
     get value() {
-        return this.__internal__raw;
+        return this.#raw;
     }
     /**
      * @description Compares the value of the input to see if there is a match
@@ -260,7 +260,7 @@ class Enum {
         else if ((0, util_1.isNumber)(other)) {
             return this.toNumber() === other;
         }
-        else if (this.__internal__isBasic && (0, util_1.isString)(other)) {
+        else if (this.#isBasic && (0, util_1.isString)(other)) {
             return this.type === other;
         }
         else if ((0, util_1.isHex)(other)) {
@@ -279,10 +279,10 @@ class Enum {
      * @description Returns a breakdown of the hex encoding for this Codec
      */
     inspect() {
-        if (this.__internal__isBasic) {
+        if (this.#isBasic) {
             return { outer: [new Uint8Array([this.index])] };
         }
-        const { inner, outer = [] } = this.__internal__raw.inspect();
+        const { inner, outer = [] } = this.#raw.inspect();
         return {
             inner,
             outer: [new Uint8Array([this.index]), ...outer]
@@ -298,17 +298,17 @@ class Enum {
      * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
      */
     toHuman(isExtended, disableAscii) {
-        return this.__internal__isBasic || this.isNone
+        return this.#isBasic || this.isNone
             ? this.type
-            : { [this.type]: this.__internal__raw.toHuman(isExtended, disableAscii) };
+            : { [this.type]: this.#raw.toHuman(isExtended, disableAscii) };
     }
     /**
      * @description Converts the Object to JSON, typically used for RPC transfers
      */
     toJSON() {
-        return this.__internal__isBasic
+        return this.#isBasic
             ? this.type
-            : { [(0, util_1.stringCamelCase)(this.type)]: this.__internal__raw.toJSON() };
+            : { [(0, util_1.stringCamelCase)(this.type)]: this.#raw.toJSON() };
     }
     /**
      * @description Returns the number representation for the value
@@ -320,23 +320,23 @@ class Enum {
      * @description Converts the value in a best-fit primitive form
      */
     toPrimitive(disableAscii) {
-        return this.__internal__isBasic
+        return this.#isBasic
             ? this.type
-            : { [(0, util_1.stringCamelCase)(this.type)]: this.__internal__raw.toPrimitive(disableAscii) };
+            : { [(0, util_1.stringCamelCase)(this.type)]: this.#raw.toPrimitive(disableAscii) };
     }
     /**
      * @description Returns a raw struct representation of the enum types
      */
     _toRawStruct() {
-        if (this.__internal__isBasic) {
-            return this.__internal__isIndexed
+        if (this.#isBasic) {
+            return this.#isIndexed
                 ? this.defKeys.reduce((out, key, index) => {
-                    out[key] = this.__internal__indexes[index];
+                    out[key] = this.#indexes[index];
                     return out;
                 }, {})
                 : this.defKeys;
         }
-        const entries = Object.entries(this.__internal__def);
+        const entries = Object.entries(this.#def);
         return (0, index_js_1.typesToMap)(this.registry, entries.reduce((out, [key, { Type }], i) => {
             out[0][i] = Type;
             out[1][i] = key;
@@ -363,10 +363,10 @@ class Enum {
      */
     toU8a(isBare) {
         return isBare
-            ? this.__internal__raw.toU8a(isBare)
+            ? this.#raw.toU8a(isBare)
             : (0, util_1.u8aConcatStrict)([
                 new Uint8Array([this.index]),
-                this.__internal__raw.toU8a(isBare)
+                this.#raw.toU8a(isBare)
             ]);
     }
 }

package/cjs/base/Option.js

@@ -56,8 +56,8 @@ class Option {
     createdAtHash;
     initialU8aLength;
     isStorageFallback;
-    __internal__Type;
-    __internal__raw;
+    #Type;
+    #raw;
     constructor(registry, typeName, value, { definition, setDefinition = util_1.identity } = {}) {
         const Type = definition || setDefinition((0, index_js_1.typeToConstructor)(registry, typeName));
         const decoded = (0, util_1.isU8a)(value) && value.length && !(0, util_1.isCodec)(value)
@@ -66,8 +66,8 @@ class Option {
                 : new Type(registry, value.subarray(1))
             : decodeOption(registry, Type, value);
         this.registry = registry;
-        this.__internal__Type = Type;
-        this.__internal__raw = decoded;
+        this.#Type = Type;
+        this.#raw = decoded;
         if (decoded?.initialU8aLength) {
             this.initialU8aLength = 1 + decoded.initialU8aLength;
         }
@@ -89,7 +89,7 @@ class Option {
      */
     get encodedLength() {
         // boolean byte (has value, doesn't have) along with wrapped length
-        return 1 + this.__internal__raw.encodedLength;
+        return 1 + this.#raw.encodedLength;
     }
     /**
      * @description returns a hash of the contents
@@ -107,7 +107,7 @@ class Option {
      * @description Checks if the Option has no value
      */
     get isNone() {
-        return this.__internal__raw instanceof None;
+        return this.#raw instanceof None;
     }
     /**
      * @description Checks if the Option has a value
@@ -119,7 +119,7 @@ class Option {
      * @description The actual value for the Option
      */
     get value() {
-        return this.__internal__raw;
+        return this.#raw;
     }
     /**
      * @description Compares the value of the input to see if there is a match
@@ -137,7 +137,7 @@ class Option {
         if (this.isNone) {
             return { outer: [new Uint8Array([0])] };
         }
-        const { inner, outer = [] } = this.__internal__raw.inspect();
+        const { inner, outer = [] } = this.#raw.inspect();
         return {
             inner,
             outer: [new Uint8Array([1]), ...outer]
@@ -157,7 +157,7 @@ class Option {
      * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
      */
     toHuman(isExtended, disableAscii) {
-        return this.__internal__raw.toHuman(isExtended, disableAscii);
+        return this.#raw.toHuman(isExtended, disableAscii);
     }
     /**
      * @description Converts the Object to JSON, typically used for RPC transfers
@@ -165,7 +165,7 @@ class Option {
     toJSON() {
         return this.isNone
             ? null
-            : this.__internal__raw.toJSON();
+            : this.#raw.toJSON();
     }
     /**
      * @description Converts the value in a best-fit primitive form
@@ -173,13 +173,13 @@ class Option {
     toPrimitive(disableAscii) {
         return this.isNone
             ? null
-            : this.__internal__raw.toPrimitive(disableAscii);
+            : this.#raw.toPrimitive(disableAscii);
     }
     /**
      * @description Returns the base runtime type name for this instance
      */
     toRawType(isBare) {
-        const wrapped = this.registry.getClassName(this.__internal__Type) || new this.__internal__Type(this.registry).toRawType();
+        const wrapped = this.registry.getClassName(this.#Type) || new this.#Type(this.registry).toRawType();
         return isBare
             ? wrapped
             : `Option<${wrapped}>`;
@@ -188,7 +188,7 @@ class Option {
      * @description Returns the string representation of the value
      */
     toString() {
-        return this.__internal__raw.toString();
+        return this.#raw.toString();
     }
     /**
      * @description Encodes the value as a Uint8Array as per the SCALE specifications
@@ -196,12 +196,12 @@ class Option {
      */
     toU8a(isBare) {
         if (isBare) {
-            return this.__internal__raw.toU8a(true);
+            return this.#raw.toU8a(true);
         }
         const u8a = new Uint8Array(this.encodedLength);
         if (this.isSome) {
             u8a.set([1]);
-            u8a.set(this.__internal__raw.toU8a(), 1);
+            u8a.set(this.#raw.toU8a(), 1);
         }
         return u8a;
     }
@@ -212,7 +212,7 @@ class Option {
         if (this.isNone) {
             throw new Error('Option: unwrapping a None value');
         }
-        return this.__internal__raw;
+        return this.#raw;
     }
     /**
      * @description Returns the value that the Option represents (if available) or defaultValue if none
@@ -230,7 +230,7 @@ class Option {
     unwrapOrDefault() {
         return this.isSome
             ? this.unwrap()
-            : new this.__internal__Type(this.registry);
+            : new this.#Type(this.registry);
     }
 }
 exports.Option = Option;

package/cjs/base/Tuple.js

@@ -40,7 +40,7 @@ function decodeTuple(registry, result, value, Classes) {
  * own type. It extends the base JS `Array` object.
  */
 class Tuple extends Array_js_1.AbstractArray {
-    __internal__Types;
+    #Types;
     constructor(registry, Types, value, { definition, setDefinition = util_1.identity } = {}) {
         const Classes = definition || setDefinition(Array.isArray(Types)
             ? [(0, index_js_1.typesToConstructors)(registry, Types), []]
@@ -51,7 +51,7 @@ class Tuple extends Array_js_1.AbstractArray {
         this.initialU8aLength = ((0, util_1.isU8a)(value)
             ? (0, index_js_1.decodeU8a)(registry, this, value, Classes)
             : decodeTuple(registry, this, value, Classes))[1];
-        this.__internal__Types = Classes;
+        this.#Types = Classes;
     }
     static with(Types) {
         let definition;
@@ -77,9 +77,9 @@ class Tuple extends Array_js_1.AbstractArray {
      * @description The types definition of the tuple
      */
     get Types() {
-        return this.__internal__Types[1].length
-            ? this.__internal__Types[1]
-            : this.__internal__Types[0].map((T) => new T(this.registry).toRawType());
+        return this.#Types[1].length
+            ? this.#Types[1]
+            : this.#Types[0].map((T) => new T(this.registry).toRawType());
     }
     /**
      * @description Returns a breakdown of the hex encoding for this Codec
@@ -93,7 +93,7 @@ class Tuple extends Array_js_1.AbstractArray {
      * @description Returns the base runtime type name for this instance
      */
     toRawType() {
-        const types = this.__internal__Types[0].map((T) => this.registry.getClassName(T) || new T(this.registry).toRawType());
+        const types = this.#Types[0].map((T) => this.registry.getClassName(T) || new T(this.registry).toRawType());
         return `(${types.join(',')})`;
     }
     /**

package/cjs/base/Vec.js

@@ -57,14 +57,14 @@ function decodeVec(registry, result, value, startAt, Type) {
  * specific encoding/decoding on top of the base type.
  */
 class Vec extends Array_js_1.AbstractArray {
-    __internal__Type;
+    #Type;
     constructor(registry, Type, value = [], { definition, setDefinition = util_1.identity } = {}) {
         const [decodeFrom, length, startAt] = decodeVecLength(value);
         super(registry, length);
-        this.__internal__Type = definition || setDefinition((0, index_js_1.typeToConstructor)(registry, Type));
+        this.#Type = definition || setDefinition((0, index_js_1.typeToConstructor)(registry, Type));
         this.initialU8aLength = ((0, util_1.isU8a)(decodeFrom)
-            ? (0, index_js_1.decodeU8aVec)(registry, this, decodeFrom, startAt, this.__internal__Type)
-            : decodeVec(registry, this, decodeFrom, startAt, this.__internal__Type))[0];
+            ? (0, index_js_1.decodeU8aVec)(registry, this, decodeFrom, startAt, this.#Type)
+            : decodeVec(registry, this, decodeFrom, startAt, this.#Type))[0];
     }
     static with(Type) {
         let definition;
@@ -80,16 +80,16 @@ class Vec extends Array_js_1.AbstractArray {
      * @description The type for the items
      */
     get Type() {
-        return this.__internal__Type.name;
+        return this.#Type.name;
     }
     /**
      * @description Finds the index of the value in the array
      */
     indexOf(other) {
         // convert type first, this removes overhead from the eq
-        const check = other instanceof this.__internal__Type
+        const check = other instanceof this.#Type
             ? other
-            : new this.__internal__Type(this.registry, other);
+            : new this.#Type(this.registry, other);
         for (let i = 0, count = this.length; i < count; i++) {
             if (check.eq(this[i])) {
                 return i;
@@ -101,7 +101,7 @@ class Vec extends Array_js_1.AbstractArray {
      * @description Returns the base runtime type name for this instance
      */
     toRawType() {
-        return `Vec<${this.registry.getClassName(this.__internal__Type) || new this.__internal__Type(this.registry).toRawType()}>`;
+        return `Vec<${this.registry.getClassName(this.#Type) || new this.#Type(this.registry).toRawType()}>`;
     }
 }
 exports.Vec = Vec;

package/cjs/base/VecFixed.js

@@ -11,13 +11,13 @@ const Vec_js_1 = require("./Vec.js");
  * This manages codec arrays of a fixed length
  */
 class VecFixed extends Array_js_1.AbstractArray {
-    __internal__Type;
+    #Type;
     constructor(registry, Type, length, value = [], { definition, setDefinition = util_1.identity } = {}) {
         super(registry, length);
-        this.__internal__Type = definition || setDefinition((0, index_js_1.typeToConstructor)(registry, Type));
+        this.#Type = definition || setDefinition((0, index_js_1.typeToConstructor)(registry, Type));
         this.initialU8aLength = ((0, util_1.isU8a)(value)
-            ? (0, index_js_1.decodeU8aVec)(registry, this, value, 0, this.__internal__Type)
-            : (0, Vec_js_1.decodeVec)(registry, this, value, 0, this.__internal__Type))[1];
+            ? (0, index_js_1.decodeU8aVec)(registry, this, value, 0, this.#Type)
+            : (0, Vec_js_1.decodeVec)(registry, this, value, 0, this.#Type))[1];
     }
     static with(Type, length) {
         let definition;
@@ -33,7 +33,7 @@ class VecFixed extends Array_js_1.AbstractArray {
      * @description The type for the items
      */
     get Type() {
-        return new this.__internal__Type(this.registry).toRawType();
+        return new this.#Type(this.registry).toRawType();
     }
     /**
      * @description The length of the value when encoded as a Uint8Array

package/cjs/extended/BTreeSet.js

@@ -61,13 +61,13 @@ class BTreeSet extends Set {
     createdAtHash;
     initialU8aLength;
     isStorageFallback;
-    __internal__ValClass;
+    #ValClass;
     constructor(registry, valType, rawValue) {
         const [ValClass, values, decodedLength] = decodeSet(registry, valType, rawValue);
         super((0, index_js_1.sortSet)(values));
         this.registry = registry;
         this.initialU8aLength = decodedLength;
-        this.__internal__ValClass = ValClass;
+        this.#ValClass = ValClass;
     }
     static with(valType) {
         return class extends BTreeSet {
@@ -153,7 +153,7 @@ class BTreeSet extends Set {
      * @description Returns the base runtime type name for this instance
      */
     toRawType() {
-        return `BTreeSet<${this.registry.getClassName(this.__internal__ValClass) || new this.__internal__ValClass(this.registry).toRawType()}>`;
+        return `BTreeSet<${this.registry.getClassName(this.#ValClass) || new this.#ValClass(this.registry).toRawType()}>`;
     }
     /**
      * @description Converts the value in a best-fit primitive form

package/cjs/extended/BitVec.js

@@ -31,29 +31,29 @@ function decodeBitVec(value) {
  * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
  */
 class BitVec extends Raw_js_1.Raw {
-    __internal__decodedLength;
-    __internal__isMsb;
+    #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, isMsb = false) {
         const [decodedLength, u8a] = decodeBitVec(value);
         super(registry, u8a);
-        this.__internal__decodedLength = decodedLength;
-        this.__internal__isMsb = isMsb;
+        this.#decodedLength = decodedLength;
+        this.#isMsb = isMsb;
     }
     /**
      * @description The length of the value when encoded as a Uint8Array
      */
     get encodedLength() {
-        return this.length + (0, util_1.compactToU8a)(this.__internal__decodedLength).length;
+        return this.length + (0, util_1.compactToU8a)(this.#decodedLength).length;
     }
     /**
      * @description Returns a breakdown of the hex encoding for this Codec
      */
     inspect() {
         return {
-            outer: [(0, util_1.compactToU8a)(this.__internal__decodedLength), super.toU8a()]
+            outer: [(0, util_1.compactToU8a)(this.#decodedLength), super.toU8a()]
         };
     }
     /**
@@ -76,7 +76,7 @@ class BitVec extends Raw_js_1.Raw {
             const off = i * 8;
             const v = map[i];
             for (let j = 0; j < 8; j++) {
-                result[off + j] = this.__internal__isMsb
+                result[off + j] = this.#isMsb
                     ? v[j]
                     : v[7 - j];
             }
@@ -89,7 +89,7 @@ class BitVec extends Raw_js_1.Raw {
     toHuman() {
         return `0b${[...this.toU8a(true)]
             .map((d) => `00000000${d.toString(2)}`.slice(-8))
-            .map((s) => this.__internal__isMsb ? s : s.split('').reverse().join(''))
+            .map((s) => this.#isMsb ? s : s.split('').reverse().join(''))
             .join('_')}`;
     }
     /**
@@ -106,7 +106,7 @@ class BitVec extends Raw_js_1.Raw {
         const bitVec = super.toU8a(isBare);
         return isBare
             ? bitVec
-            : (0, util_1.u8aConcatStrict)([(0, util_1.compactToU8a)(this.__internal__decodedLength), bitVec]);
+            : (0, util_1.u8aConcatStrict)([(0, util_1.compactToU8a)(this.#decodedLength), bitVec]);
     }
 }
 exports.BitVec = BitVec;

package/cjs/extended/Map.js

@@ -80,17 +80,17 @@ class CodecMap extends Map {
     createdAtHash;
     initialU8aLength;
     isStorageFallback;
-    __internal__KeyClass;
-    __internal__ValClass;
-    __internal__type;
+    #KeyClass;
+    #ValClass;
+    #type;
     constructor(registry, keyType, valType, rawValue, type = 'HashMap') {
         const [KeyClass, ValClass, decoded, decodedLength] = decodeMap(registry, keyType, valType, rawValue);
         super(type === 'BTreeMap' ? (0, index_js_1.sortMap)(decoded) : decoded);
         this.registry = registry;
         this.initialU8aLength = decodedLength;
-        this.__internal__KeyClass = KeyClass;
-        this.__internal__ValClass = ValClass;
-        this.__internal__type = type;
+        this.#KeyClass = KeyClass;
+        this.#ValClass = ValClass;
+        this.#type = type;
     }
     /**
      * @description The length of the value when encoded as a Uint8Array
@@ -178,7 +178,7 @@ class CodecMap extends Map {
      * @description Returns the base runtime type name for this instance
      */
     toRawType() {
-        return `${this.__internal__type}<${this.registry.getClassName(this.__internal__KeyClass) || new this.__internal__KeyClass(this.registry).toRawType()},${this.registry.getClassName(this.__internal__ValClass) || new this.__internal__ValClass(this.registry).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

package/cjs/extended/Range.js

@@ -8,10 +8,10 @@ const Tuple_js_1 = require("../base/Tuple.js");
  * Rust `Range<T>` representation
  */
 class Range extends Tuple_js_1.Tuple {
-    __internal__rangeName;
+    #rangeName;
     constructor(registry, Type, value, { rangeName = 'Range' } = {}) {
         super(registry, [Type, Type], value);
-        this.__internal__rangeName = rangeName;
+        this.#rangeName = rangeName;
     }
     static with(Type) {
         return class extends Range {
@@ -36,7 +36,7 @@ class Range extends Tuple_js_1.Tuple {
      * @description Returns the base runtime type name for this instance
      */
     toRawType() {
-        return `${this.__internal__rangeName}<${this.start.toRawType()}>`;
+        return `${this.#rangeName}<${this.start.toRawType()}>`;
     }
 }
 exports.Range = Range;