@polkadot/types-codec 16.2.1 → 16.2.2

package/base/Option.js

@@ -53,8 +53,8 @@ export class Option {
     createdAtHash;
     initialU8aLength;
     isStorageFallback;
-    __internal__Type;
-    __internal__raw;
+    #Type;
+    #raw;
     constructor(registry, typeName, value, { definition, setDefinition = identity } = {}) {
         const Type = definition || setDefinition(typeToConstructor(registry, typeName));
         const decoded = isU8a(value) && value.length && !isCodec(value)
@@ -63,8 +63,8 @@ export 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;
         }
@@ -86,7 +86,7 @@ export 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
@@ -104,7 +104,7 @@ export 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
@@ -116,7 +116,7 @@ export 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
@@ -134,7 +134,7 @@ export 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]
@@ -154,7 +154,7 @@ export 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
@@ -162,7 +162,7 @@ export class Option {
     toJSON() {
         return this.isNone
             ? null
-            : this.__internal__raw.toJSON();
+            : this.#raw.toJSON();
     }
     /**
      * @description Converts the value in a best-fit primitive form
@@ -170,13 +170,13 @@ export 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}>`;
@@ -185,7 +185,7 @@ export 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
@@ -193,12 +193,12 @@ export 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;
     }
@@ -209,7 +209,7 @@ export 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
@@ -227,6 +227,6 @@ export class Option {
     unwrapOrDefault() {
         return this.isSome
             ? this.unwrap()
-            : new this.__internal__Type(this.registry);
+            : new this.#Type(this.registry);
     }
 }

package/base/Tuple.js

@@ -37,7 +37,7 @@ function decodeTuple(registry, result, value, Classes) {
  * own type. It extends the base JS `Array` object.
  */
 export class Tuple extends AbstractArray {
-    __internal__Types;
+    #Types;
     constructor(registry, Types, value, { definition, setDefinition = identity } = {}) {
         const Classes = definition || setDefinition(Array.isArray(Types)
             ? [typesToConstructors(registry, Types), []]
@@ -48,7 +48,7 @@ export class Tuple extends AbstractArray {
         this.initialU8aLength = (isU8a(value)
             ? decodeU8a(registry, this, value, Classes)
             : decodeTuple(registry, this, value, Classes))[1];
-        this.__internal__Types = Classes;
+        this.#Types = Classes;
     }
     static with(Types) {
         let definition;
@@ -74,9 +74,9 @@ export class Tuple extends 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
@@ -90,7 +90,7 @@ export class Tuple extends 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/base/Vec.js

@@ -53,14 +53,14 @@ export function decodeVec(registry, result, value, startAt, Type) {
  * specific encoding/decoding on top of the base type.
  */
 export class Vec extends AbstractArray {
-    __internal__Type;
+    #Type;
     constructor(registry, Type, value = [], { definition, setDefinition = identity } = {}) {
         const [decodeFrom, length, startAt] = decodeVecLength(value);
         super(registry, length);
-        this.__internal__Type = definition || setDefinition(typeToConstructor(registry, Type));
+        this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
         this.initialU8aLength = (isU8a(decodeFrom)
-            ? decodeU8aVec(registry, this, decodeFrom, startAt, this.__internal__Type)
-            : decodeVec(registry, this, decodeFrom, startAt, this.__internal__Type))[0];
+            ? decodeU8aVec(registry, this, decodeFrom, startAt, this.#Type)
+            : decodeVec(registry, this, decodeFrom, startAt, this.#Type))[0];
     }
     static with(Type) {
         let definition;
@@ -76,16 +76,16 @@ export class Vec extends 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;
@@ -97,6 +97,6 @@ export class Vec extends 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()}>`;
     }
 }

package/base/VecFixed.js

@@ -8,13 +8,13 @@ import { decodeVec } from './Vec.js';
  * This manages codec arrays of a fixed length
  */
 export class VecFixed extends AbstractArray {
-    __internal__Type;
+    #Type;
     constructor(registry, Type, length, value = [], { definition, setDefinition = identity } = {}) {
         super(registry, length);
-        this.__internal__Type = definition || setDefinition(typeToConstructor(registry, Type));
+        this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
         this.initialU8aLength = (isU8a(value)
-            ? decodeU8aVec(registry, this, value, 0, this.__internal__Type)
-            : decodeVec(registry, this, value, 0, this.__internal__Type))[1];
+            ? decodeU8aVec(registry, this, value, 0, this.#Type)
+            : decodeVec(registry, this, value, 0, this.#Type))[1];
     }
     static with(Type, length) {
         let definition;
@@ -30,7 +30,7 @@ export class VecFixed extends 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/abstract/Base.js

@@ -10,10 +10,10 @@ 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;
     }
     /**
@@ -32,74 +32,74 @@ 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;
     }
 }
 exports.AbstractBase = AbstractBase;

package/cjs/abstract/Int.js

@@ -67,7 +67,7 @@ class AbstractInt extends util_1.BN {
     createdAtHash;
     initialU8aLength;
     isStorageFallback;
-    __internal__bitLength;
+    #bitLength;
     constructor(registry, value = 0, bitLength = exports.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:
@@ -80,9 +80,9 @@ class AbstractInt extends util_1.BN {
                 : (0, util_1.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);
@@ -109,7 +109,7 @@ class AbstractInt extends util_1.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
@@ -135,7 +135,7 @@ class AbstractInt extends util_1.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
@@ -184,8 +184,8 @@ class AbstractInt extends util_1.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/cjs/base/Compact.js

@@ -34,14 +34,14 @@ class Compact {
     createdAtHash;
     initialU8aLength;
     isStorageFallback;
-    __internal__Type;
-    __internal__raw;
+    #Type;
+    #raw;
     constructor(registry, Type, value = 0, { definition, setDefinition = util_1.identity } = {}) {
         this.registry = registry;
-        this.__internal__Type = definition || setDefinition((0, index_js_1.typeToConstructor)(registry, Type));
-        const [raw, decodedLength] = decodeCompact(registry, this.__internal__Type, value);
+        this.#Type = definition || setDefinition((0, index_js_1.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;
@@ -69,20 +69,20 @@ 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);
     }
     /**
@@ -97,67 +97,67 @@ 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 (0, util_1.compactToU8a)(this.__internal__raw.toBn());
+        return (0, util_1.compactToU8a)(this.#raw.toBn());
     }
     /**
      * @description Returns the embedded [[UInt]] or [[Moment]] value
      */
     unwrap() {
-        return this.__internal__raw;
+        return this.#raw;
     }
 }
 exports.Compact = Compact;

package/cjs/base/DoNotConstruct.js

@@ -10,11 +10,11 @@ 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 {
@@ -27,73 +27,73 @@ 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;
     }
 }
 exports.DoNotConstruct = DoNotConstruct;