@polkadot/types-codec 16.2.1 → 16.3.1

package/abstract/Base.js

@@ -7,10 +7,10 @@ export class AbstractBase {
     createdAtHash;
     initialU8aLength;
     isStorageFallback;
-    __internal__raw;
+    #raw;
     constructor(registry, value, initialU8aLength) {
         this.initialU8aLength = initialU8aLength;
-        this.__internal__raw = value;
+        this.#raw = value;
         this.registry = registry;
     }
     /**
@@ -29,73 +29,73 @@ export class AbstractBase {
      * @description returns the inner (wrapped value)
      */
     get inner() {
-        return this.__internal__raw;
+        return this.#raw;
     }
     /**
      * @description Checks if the value is an empty value
      */
     get isEmpty() {
-        return this.__internal__raw.isEmpty;
+        return this.#raw.isEmpty;
     }
     /**
      * @description Compares the value of the input to see if there is a match
      */
     eq(other) {
-        return this.__internal__raw.eq(other);
+        return this.#raw.eq(other);
     }
     /**
      * @description Returns a breakdown of the hex encoding for this Codec
      */
     inspect() {
-        return this.__internal__raw.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.__internal__raw.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, 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
      */
     toJSON() {
-        return this.__internal__raw.toJSON();
+        return this.#raw.toJSON();
     }
     /**
      * @description Converts the value in a best-fit primitive form
      */
     toPrimitive(disableAscii) {
-        return this.__internal__raw.toPrimitive(disableAscii);
+        return this.#raw.toPrimitive(disableAscii);
     }
     /**
      * @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
      * @param isBare true when the value has none of the type-specific prefixes (internal)
      */
     toU8a(isBare) {
-        return this.__internal__raw.toU8a(isBare);
+        return this.#raw.toU8a(isBare);
     }
     /**
      * @description Returns the inner wrapped value (equivalent to valueOf)
      */
     unwrap() {
-        return this.__internal__raw;
+        return this.#raw;
     }
     /**
      * @description Returns the inner wrapped value
      */
     valueOf() {
-        return this.__internal__raw;
+        return this.#raw;
     }
 }

package/abstract/Int.js

@@ -64,7 +64,7 @@ export class AbstractInt extends BN {
     createdAtHash;
     initialU8aLength;
     isStorageFallback;
-    __internal__bitLength;
+    #bitLength;
     constructor(registry, value = 0, bitLength = DEFAULT_UINT_BITS, isSigned = false) {
         // Construct via a string/number, which will be passed in the BN constructor.
         // It would be ideal to actually return a BN, but there is an issue:
@@ -77,9 +77,9 @@ export class AbstractInt extends BN {
                 : u8aToBn(value.subarray(0, bitLength / 8), { isLe: true, isNegative: isSigned }).toString()
             : decodeAbstractInt(value, isSigned));
         this.registry = registry;
-        this.__internal__bitLength = bitLength;
-        this.encodedLength = this.__internal__bitLength / 8;
-        this.initialU8aLength = this.__internal__bitLength / 8;
+        this.#bitLength = bitLength;
+        this.encodedLength = this.#bitLength / 8;
+        this.initialU8aLength = this.#bitLength / 8;
         this.isUnsigned = !isSigned;
         const isNegative = this.isNeg();
         const maxBits = bitLength - (isSigned && !isNegative ? 1 : 0);
@@ -106,7 +106,7 @@ export class AbstractInt extends BN {
      * @description Returns the number of bits in the value
      */
     bitLength() {
-        return this.__internal__bitLength;
+        return this.#bitLength;
     }
     /**
      * @description Compares the value of the input to see if there is a match
@@ -132,7 +132,7 @@ export class AbstractInt extends BN {
      */
     isMax() {
         const u8a = this.toU8a().filter((b) => b === 0xff);
-        return u8a.length === (this.__internal__bitLength / 8);
+        return u8a.length === (this.#bitLength / 8);
     }
     /**
      * @description Returns a BigInt representation of the number
@@ -181,8 +181,8 @@ export class AbstractInt extends BN {
         // FIXME this return type should by string | number, however BN returns string
         // Options here are
         //   - super.bitLength() - the actual used bits, use hex when close to MAX_SAFE_INTEGER
-        //   - this.__internal__bitLength - the max used bits, use hex when larger than native Rust type
-        return onlyHex || (this.__internal__bitLength > 128) || (super.bitLength() > MAX_NUMBER_BITS)
+        //   - this.#bitLength - the max used bits, use hex when larger than native Rust type
+        return onlyHex || (this.#bitLength > 128) || (super.bitLength() > MAX_NUMBER_BITS)
             ? this.toHex()
             : this.toNumber();
     }

package/base/Compact.js

@@ -31,14 +31,14 @@ export class Compact {
     createdAtHash;
     initialU8aLength;
     isStorageFallback;
-    __internal__Type;
-    __internal__raw;
+    #Type;
+    #raw;
     constructor(registry, Type, value = 0, { definition, setDefinition = identity } = {}) {
         this.registry = registry;
-        this.__internal__Type = definition || setDefinition(typeToConstructor(registry, Type));
-        const [raw, decodedLength] = decodeCompact(registry, this.__internal__Type, value);
+        this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
+        const [raw, decodedLength] = decodeCompact(registry, this.#Type, value);
         this.initialU8aLength = decodedLength;
-        this.__internal__raw = raw;
+        this.#raw = raw;
     }
     static with(Type) {
         let definition;
@@ -66,20 +66,20 @@ export class Compact {
      * @description Checks if the value is an empty value
      */
     get isEmpty() {
-        return this.__internal__raw.isEmpty;
+        return this.#raw.isEmpty;
     }
     /**
      * @description Returns the number of bits in the value
      */
     bitLength() {
-        return this.__internal__raw.bitLength();
+        return this.#raw.bitLength();
     }
     /**
      * @description Compares the value of the input to see if there is a match
      */
     eq(other) {
-        return this.__internal__raw.eq(other instanceof Compact
-            ? other.__internal__raw
+        return this.#raw.eq(other instanceof Compact
+            ? other.#raw
             : other);
     }
     /**
@@ -94,66 +94,66 @@ export class Compact {
      * @description Returns a BigInt representation of the number
      */
     toBigInt() {
-        return this.__internal__raw.toBigInt();
+        return this.#raw.toBigInt();
     }
     /**
      * @description Returns the BN representation of the number
      */
     toBn() {
-        return this.__internal__raw.toBn();
+        return this.#raw.toBn();
     }
     /**
      * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
      */
     toHex(isLe) {
-        return this.__internal__raw.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, 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
      */
     toJSON() {
-        return this.__internal__raw.toJSON();
+        return this.#raw.toJSON();
     }
     /**
      * @description Returns the number representation for the value
      */
     toNumber() {
-        return this.__internal__raw.toNumber();
+        return this.#raw.toNumber();
     }
     /**
      * @description Converts the value in a best-fit primitive form
      */
     toPrimitive(disableAscii) {
-        return this.__internal__raw.toPrimitive(disableAscii);
+        return this.#raw.toPrimitive(disableAscii);
     }
     /**
      * @description Returns the base runtime type name for this instance
      */
     toRawType() {
-        return `Compact<${this.registry.getClassName(this.__internal__Type) || this.__internal__raw.toRawType()}>`;
+        return `Compact<${this.registry.getClassName(this.#Type) || this.#raw.toRawType()}>`;
     }
     /**
      * @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
      */
     toU8a(_isBare) {
-        return compactToU8a(this.__internal__raw.toBn());
+        return compactToU8a(this.#raw.toBn());
     }
     /**
      * @description Returns the embedded [[UInt]] or [[Moment]] value
      */
     unwrap() {
-        return this.__internal__raw;
+        return this.#raw;
     }
 }

package/base/DoNotConstruct.js

@@ -7,11 +7,11 @@ export class DoNotConstruct {
     registry;
     createdAtHash;
     isStorageFallback;
-    __internal__neverError;
+    #neverError;
     constructor(registry, typeName = 'DoNotConstruct') {
         this.registry = registry;
-        this.__internal__neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`);
-        throw this.__internal__neverError;
+        this.#neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`);
+        throw this.#neverError;
     }
     static with(typeName) {
         return class extends DoNotConstruct {
@@ -24,72 +24,72 @@ export class DoNotConstruct {
      * @description The length of the value when encoded as a Uint8Array
      */
     get encodedLength() {
-        throw this.__internal__neverError;
+        throw this.#neverError;
     }
     /**
      * @description returns a hash of the contents
      */
     get hash() {
-        throw this.__internal__neverError;
+        throw this.#neverError;
     }
     /**
      * @description Checks if the value is an empty value (always true)
      */
     get isEmpty() {
-        throw this.__internal__neverError;
+        throw this.#neverError;
     }
     /**
      * @description Unimplemented
      */
     eq() {
-        throw this.__internal__neverError;
+        throw this.#neverError;
     }
     /**
      * @description Unimplemented
      */
     inspect() {
-        throw this.__internal__neverError;
+        throw this.#neverError;
     }
     /**
      * @description Unimplemented
      */
     toHex() {
-        throw this.__internal__neverError;
+        throw this.#neverError;
     }
     /**
      * @description Unimplemented
      */
     toHuman() {
-        throw this.__internal__neverError;
+        throw this.#neverError;
     }
     /**
      * @description Unimplemented
      */
     toJSON() {
-        throw this.__internal__neverError;
+        throw this.#neverError;
     }
     /**
      * @description Unimplemented
      */
     toPrimitive() {
-        throw this.__internal__neverError;
+        throw this.#neverError;
     }
     /**
      * @description Unimplemented
      */
     toRawType() {
-        throw this.__internal__neverError;
+        throw this.#neverError;
     }
     /**
      * @description Unimplemented
      */
     toString() {
-        throw this.__internal__neverError;
+        throw this.#neverError;
     }
     /**
      * @description Unimplemented
      */
     toU8a() {
-        throw this.__internal__neverError;
+        throw this.#neverError;
     }
 }

package/base/Enum.js

@@ -127,12 +127,12 @@ export 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 = identity } = {}) {
         const { def, isBasic, isIndexed } = definition || setDefinition(extractDef(registry, Types));
         // shortcut isU8a as used in SCALE decoding
@@ -140,14 +140,14 @@ export 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) {
@@ -184,7 +184,7 @@ export 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
@@ -196,55 +196,55 @@ export 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;
+        return this.#raw instanceof 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
@@ -257,7 +257,7 @@ export class Enum {
         else if (isNumber(other)) {
             return this.toNumber() === other;
         }
-        else if (this.__internal__isBasic && isString(other)) {
+        else if (this.#isBasic && isString(other)) {
             return this.type === other;
         }
         else if (isHex(other)) {
@@ -276,10 +276,10 @@ export 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]
@@ -295,17 +295,17 @@ export 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
-            : { [stringCamelCase(this.type)]: this.__internal__raw.toJSON() };
+            : { [stringCamelCase(this.type)]: this.#raw.toJSON() };
     }
     /**
      * @description Returns the number representation for the value
@@ -317,23 +317,23 @@ export class Enum {
      * @description Converts the value in a best-fit primitive form
      */
     toPrimitive(disableAscii) {
-        return this.__internal__isBasic
+        return this.#isBasic
             ? this.type
-            : { [stringCamelCase(this.type)]: this.__internal__raw.toPrimitive(disableAscii) };
+            : { [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 typesToMap(this.registry, entries.reduce((out, [key, { Type }], i) => {
             out[0][i] = Type;
             out[1][i] = key;
@@ -360,10 +360,10 @@ export class Enum {
      */
     toU8a(isBare) {
         return isBare
-            ? this.__internal__raw.toU8a(isBare)
+            ? this.#raw.toU8a(isBare)
             : u8aConcatStrict([
                 new Uint8Array([this.index]),
-                this.__internal__raw.toU8a(isBare)
+                this.#raw.toU8a(isBare)
             ]);
     }
 }