@polkadot/types-codec 9.14.2 → 10.1.1

package/base/Compact.js

@@ -1,24 +1,28 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+var _Compact_Type, _Compact_raw;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { compactFromU8a, compactFromU8aLim, compactToU8a, isU8a } from '@polkadot/util';
-import { typeToConstructor } from "../utils/index.js";
+import { typeToConstructor } from '../utils/index.js';
 function noopSetDefinition(d) {
-  return d;
+    return d;
 }
 function decodeCompact(registry, Type, value) {
-  if (isU8a(value)) {
-    const [decodedLength, bn] = (value[0] & 0b11) < 0b11 ? compactFromU8aLim(value) : compactFromU8a(value);
-    return [new Type(registry, bn), decodedLength];
-  } else if (value instanceof Compact) {
-    const raw = value.unwrap();
-    return raw instanceof Type ? [raw, 0] : [new Type(registry, raw), 0];
-  } else if (value instanceof Type) {
-    return [value, 0];
-  }
-  return [new Type(registry, value), 0];
+    if (isU8a(value)) {
+        const [decodedLength, bn] = (value[0] & 0b11) < 0b11
+            ? compactFromU8aLim(value)
+            : compactFromU8a(value);
+        return [new Type(registry, bn), decodedLength];
+    }
+    else if (value instanceof Compact) {
+        const raw = value.unwrap();
+        return raw instanceof Type
+            ? [raw, 0]
+            : [new Type(registry, raw), 0];
+    }
+    else if (value instanceof Type) {
+        return [value, 0];
+    }
+    return [new Type(registry, value), 0];
 }
-
 /**
  * @name Compact
  * @description
@@ -28,153 +32,132 @@ function decodeCompact(registry, Type, value) {
  * a number and making the compact representation thereof
  */
 export class Compact {
-  #Type;
-  #raw;
-  constructor(registry, Type, value = 0, {
-    definition,
-    setDefinition = noopSetDefinition
-  } = {}) {
-    this.registry = registry;
-    this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
-    const [raw, decodedLength] = decodeCompact(registry, this.#Type, value);
-    this.initialU8aLength = decodedLength;
-    this.#raw = raw;
-  }
-  static with(Type) {
-    let definition;
-
-    // eslint-disable-next-line no-return-assign
-    const setDefinition = d => definition = d;
-    return class extends Compact {
-      constructor(registry, value) {
-        super(registry, Type, value, {
-          definition,
-          setDefinition
-        });
-      }
-    };
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  get encodedLength() {
-    return this.toU8a().length;
-  }
-
-  /**
-   * @description returns a hash of the contents
-   */
-  get hash() {
-    return this.registry.hash(this.toU8a());
-  }
-
-  /**
-   * @description Checks if the value is an empty value
-   */
-  get isEmpty() {
-    return this.#raw.isEmpty;
-  }
-
-  /**
-   * @description Returns the number of bits in the value
-   */
-  bitLength() {
-    return this.#raw.bitLength();
-  }
-
-  /**
-   * @description Compares the value of the input to see if there is a match
-   */
-  eq(other) {
-    return this.#raw.eq(other instanceof Compact ? other.#raw : other);
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  inspect() {
-    return {
-      outer: [this.toU8a()]
-    };
-  }
-
-  /**
-   * @description Returns a BigInt representation of the number
-   */
-  toBigInt() {
-    return this.#raw.toBigInt();
-  }
-
-  /**
-   * @description Returns the BN representation of the number
-   */
-  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.#raw.toHex(isLe);
-  }
-
-  /**
-   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-   */
-  toHuman(isExtended) {
-    return this.#raw.toHuman(isExtended);
-  }
-
-  /**
-   * @description Converts the Object to JSON, typically used for RPC transfers
-   */
-  toJSON() {
-    return this.#raw.toJSON();
-  }
-
-  /**
-   * @description Returns the number representation for the value
-   */
-  toNumber() {
-    return this.#raw.toNumber();
-  }
-
-  /**
-   * @description Converts the value in a best-fit primitive form
-   */
-  toPrimitive() {
-    return this.#raw.toPrimitive();
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  toRawType() {
-    return `Compact<${this.registry.getClassName(this.#Type) || this.#raw.toRawType()}>`;
-  }
-
-  /**
-   * @description Returns the string representation of the value
-   */
-  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)
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  toU8a(isBare) {
-    return compactToU8a(this.#raw.toBn());
-  }
-
-  /**
-   * @description Returns the embedded [[UInt]] or [[Moment]] value
-   */
-  unwrap() {
-    return this.#raw;
-  }
-}
+    constructor(registry, Type, value = 0, { definition, setDefinition = noopSetDefinition } = {}) {
+        _Compact_Type.set(this, void 0);
+        _Compact_raw.set(this, void 0);
+        this.registry = registry;
+        __classPrivateFieldSet(this, _Compact_Type, definition || setDefinition(typeToConstructor(registry, Type)), "f");
+        const [raw, decodedLength] = decodeCompact(registry, __classPrivateFieldGet(this, _Compact_Type, "f"), value);
+        this.initialU8aLength = decodedLength;
+        __classPrivateFieldSet(this, _Compact_raw, raw, "f");
+    }
+    static with(Type) {
+        let definition;
+        // eslint-disable-next-line no-return-assign
+        const setDefinition = (d) => (definition = d);
+        return class extends Compact {
+            constructor(registry, value) {
+                super(registry, Type, value, { definition, setDefinition });
+            }
+        };
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        return this.toU8a().length;
+    }
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash() {
+        return this.registry.hash(this.toU8a());
+    }
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty() {
+        return __classPrivateFieldGet(this, _Compact_raw, "f").isEmpty;
+    }
+    /**
+     * @description Returns the number of bits in the value
+     */
+    bitLength() {
+        return __classPrivateFieldGet(this, _Compact_raw, "f").bitLength();
+    }
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other) {
+        return __classPrivateFieldGet(this, _Compact_raw, "f").eq(other instanceof Compact
+            ? __classPrivateFieldGet(other, _Compact_raw, "f")
+            : other);
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return {
+            outer: [this.toU8a()]
+        };
+    }
+    /**
+     * @description Returns a BigInt representation of the number
+     */
+    toBigInt() {
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toBigInt();
+    }
+    /**
+     * @description Returns the BN representation of the number
+     */
+    toBn() {
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toBn();
+    }
+    /**
+     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+     */
+    toHex(isLe) {
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toHex(isLe);
+    }
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended) {
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toHuman(isExtended);
+    }
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON() {
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toJSON();
+    }
+    /**
+     * @description Returns the number representation for the value
+     */
+    toNumber() {
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toNumber();
+    }
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive() {
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toPrimitive();
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return `Compact<${this.registry.getClassName(__classPrivateFieldGet(this, _Compact_Type, "f")) || __classPrivateFieldGet(this, _Compact_raw, "f").toRawType()}>`;
+    }
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString() {
+        return __classPrivateFieldGet(this, _Compact_raw, "f").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)
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    toU8a(isBare) {
+        return compactToU8a(__classPrivateFieldGet(this, _Compact_raw, "f").toBn());
+    }
+    /**
+     * @description Returns the embedded [[UInt]] or [[Moment]] value
+     */
+    unwrap() {
+        return __classPrivateFieldGet(this, _Compact_raw, "f");
+    }
+}
+_Compact_Type = new WeakMap(), _Compact_raw = new WeakMap();

package/base/DoNotConstruct.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, Inspect, IU8a, Registry } from '../types';
+import type { AnyJson, Codec, CodecClass, Inspect, IU8a, Registry } from '../types/index.js';
 /**
  * @name DoNotConstruct
  * @description

package/base/DoNotConstruct.js

@@ -1,71 +1,68 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+var _DoNotConstruct_neverError;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 /**
  * @name DoNotConstruct
  * @description
  * An unknown type that fails on construction with the type info
  */
 export class DoNotConstruct {
-  #neverError;
-  constructor(registry, typeName = 'DoNotConstruct') {
-    this.registry = registry;
-    this.#neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`);
-    throw this.#neverError;
-  }
-  static with(typeName) {
-    return class extends DoNotConstruct {
-      constructor(registry) {
-        super(registry, typeName);
-      }
-    };
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  get encodedLength() {
-    throw this.#neverError;
-  }
-
-  /**
-   * @description returns a hash of the contents
-   */
-  get hash() {
-    throw this.#neverError;
-  }
-
-  /**
-   * @description Checks if the value is an empty value (always true)
-   */
-  get isEmpty() {
-    throw this.#neverError;
-  }
-  eq() {
-    throw this.#neverError;
-  }
-  inspect() {
-    throw this.#neverError;
-  }
-  toHex() {
-    throw this.#neverError;
-  }
-  toHuman() {
-    throw this.#neverError;
-  }
-  toJSON() {
-    throw this.#neverError;
-  }
-  toPrimitive() {
-    throw this.#neverError;
-  }
-  toRawType() {
-    throw this.#neverError;
-  }
-  toString() {
-    throw this.#neverError;
-  }
-  toU8a() {
-    throw this.#neverError;
-  }
-}
+    constructor(registry, typeName = 'DoNotConstruct') {
+        _DoNotConstruct_neverError.set(this, void 0);
+        this.registry = registry;
+        __classPrivateFieldSet(this, _DoNotConstruct_neverError, new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`), "f");
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+    static with(typeName) {
+        return class extends DoNotConstruct {
+            constructor(registry) {
+                super(registry, typeName);
+            }
+        };
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash() {
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+    /**
+     * @description Checks if the value is an empty value (always true)
+     */
+    get isEmpty() {
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+    eq() {
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+    inspect() {
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+    toHex() {
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+    toHuman() {
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+    toJSON() {
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+    toPrimitive() {
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+    toRawType() {
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+    toString() {
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+    toU8a() {
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+    }
+}
+_DoNotConstruct_neverError = new WeakMap();

package/base/Enum.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, IEnum, Inspect, IU8a, Registry } from '../types';
+import type { AnyJson, Codec, CodecClass, IEnum, Inspect, IU8a, Registry } from '../types/index.js';
 export interface EnumCodecClass<T = Codec> {
     new (registry: Registry, value?: any, index?: number): T;
 }