@polkadot/types-codec 9.14.2 → 10.0.1

package/cjs/base/Tuple.js

@@ -1,126 +1,120 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var _Tuple_Types;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tuple = void 0;
-var _util = require("@polkadot/util");
-var _Array = require("../abstract/Array");
-var _utils = require("../utils");
-// 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 Array_1 = require("../abstract/Array");
+const utils_1 = require("../utils");
 function noopSetDefinition(d) {
-  return d;
+    return d;
 }
-
 /** @internal */
 function decodeTuple(registry, result, value, Classes) {
-  if (Array.isArray(value)) {
-    const Types = Classes[0];
-    for (let i = 0; i < Types.length; i++) {
-      try {
-        const entry = value == null ? void 0 : value[i];
-        result[i] = entry instanceof Types[i] ? entry : new Types[i](registry, entry);
-      } catch (error) {
-        throw new Error(`Tuple: failed on ${i}:: ${error.message}`);
-      }
+    if (Array.isArray(value)) {
+        const Types = Classes[0];
+        for (let i = 0; i < Types.length; i++) {
+            try {
+                const entry = value?.[i];
+                result[i] = entry instanceof Types[i]
+                    ? entry
+                    : new Types[i](registry, entry);
+            }
+            catch (error) {
+                throw new Error(`Tuple: failed on ${i}:: ${error.message}`);
+            }
+        }
+        return [result, 0];
     }
-    return [result, 0];
-  } else if ((0, _util.isHex)(value)) {
-    return (0, _utils.decodeU8a)(registry, result, (0, _util.u8aToU8a)(value), Classes);
-  } else if (!value || !result.length) {
-    const Types = Classes[0];
-    for (let i = 0; i < Types.length; i++) {
-      result[i] = new Types[i](registry);
+    else if ((0, util_1.isHex)(value)) {
+        return (0, utils_1.decodeU8a)(registry, result, (0, util_1.u8aToU8a)(value), Classes);
     }
-    return [result, 0];
-  }
-  throw new Error(`Expected array input to Tuple decoding, found ${typeof value}: ${(0, _util.stringify)(value)}`);
+    else if (!value || !result.length) {
+        const Types = Classes[0];
+        for (let i = 0; i < Types.length; i++) {
+            result[i] = new Types[i](registry);
+        }
+        return [result, 0];
+    }
+    throw new Error(`Expected array input to Tuple decoding, found ${typeof value}: ${(0, util_1.stringify)(value)}`);
 }
-
 /**
  * @name Tuple
  * @description
  * A Tuple defines an anonymous fixed-length array, where each element has its
  * own type. It extends the base JS `Array` object.
  */
-class Tuple extends _Array.AbstractArray {
-  #Types;
-  constructor(registry, Types, value) {
-    let {
-      definition,
-      setDefinition = noopSetDefinition
-    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-    const Classes = definition || setDefinition(Array.isArray(Types) ? [Types.map(t => (0, _utils.typeToConstructor)(registry, t)), []] : (0, _util.isFunction)(Types) || (0, _util.isString)(Types) ? [[(0, _utils.typeToConstructor)(registry, Types)], []] : (0, _utils.mapToTypeMap)(registry, Types));
-    super(registry, Classes[0].length);
-    this.initialU8aLength = ((0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, this, value, Classes) : decodeTuple(registry, this, value, Classes))[1];
-    this.#Types = Classes;
-  }
-  static with(Types) {
-    let definition;
-
-    // eslint-disable-next-line no-return-assign
-    const setDefinition = d => definition = d;
-    return class extends Tuple {
-      constructor(registry, value) {
-        super(registry, Types, value, {
-          definition,
-          setDefinition
-        });
-      }
-    };
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  get encodedLength() {
-    let total = 0;
-    for (let i = 0; i < this.length; i++) {
-      total += this[i].encodedLength;
+class Tuple extends Array_1.AbstractArray {
+    constructor(registry, Types, value, { definition, setDefinition = noopSetDefinition } = {}) {
+        const Classes = definition || setDefinition(Array.isArray(Types)
+            ? [Types.map((t) => (0, utils_1.typeToConstructor)(registry, t)), []]
+            : (0, util_1.isFunction)(Types) || (0, util_1.isString)(Types)
+                ? [[(0, utils_1.typeToConstructor)(registry, Types)], []]
+                : (0, utils_1.mapToTypeMap)(registry, Types));
+        super(registry, Classes[0].length);
+        _Tuple_Types.set(this, void 0);
+        this.initialU8aLength = ((0, util_1.isU8a)(value)
+            ? (0, utils_1.decodeU8a)(registry, this, value, Classes)
+            : decodeTuple(registry, this, value, Classes))[1];
+        tslib_1.__classPrivateFieldSet(this, _Tuple_Types, Classes, "f");
+    }
+    static with(Types) {
+        let definition;
+        // eslint-disable-next-line no-return-assign
+        const setDefinition = (d) => definition = d;
+        return class extends Tuple {
+            constructor(registry, value) {
+                super(registry, Types, value, { definition, setDefinition });
+            }
+        };
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        let total = 0;
+        for (let i = 0; i < this.length; i++) {
+            total += this[i].encodedLength;
+        }
+        return total;
+    }
+    /**
+     * @description The types definition of the tuple
+     */
+    get Types() {
+        return tslib_1.__classPrivateFieldGet(this, _Tuple_Types, "f")[1].length
+            ? tslib_1.__classPrivateFieldGet(this, _Tuple_Types, "f")[1]
+            : tslib_1.__classPrivateFieldGet(this, _Tuple_Types, "f")[0].map((T) => new T(this.registry).toRawType());
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return {
+            inner: this.inspectInner()
+        };
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        const types = tslib_1.__classPrivateFieldGet(this, _Tuple_Types, "f")[0].map((T) => this.registry.getClassName(T) || new T(this.registry).toRawType());
+        return `(${types.join(',')})`;
+    }
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString() {
+        // Overwrite the default toString representation of Array.
+        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) {
+        return (0, util_1.u8aConcatStrict)(this.toU8aInner(isBare));
     }
-    return total;
-  }
-
-  /**
-   * @description The types definition of the tuple
-   */
-  get Types() {
-    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
-   */
-  inspect() {
-    return {
-      inner: this.inspectInner()
-    };
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  toRawType() {
-    const types = this.#Types[0].map(T => this.registry.getClassName(T) || new T(this.registry).toRawType());
-    return `(${types.join(',')})`;
-  }
-
-  /**
-   * @description Returns the string representation of the value
-   */
-  toString() {
-    // Overwrite the default toString representation of Array.
-    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) {
-    return (0, _util.u8aConcatStrict)(this.toU8aInner(isBare));
-  }
 }
-exports.Tuple = Tuple;
+exports.Tuple = Tuple;
+_Tuple_Types = new WeakMap();

package/cjs/base/UInt.js

@@ -1,13 +1,7 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.UInt = void 0;
-var _Int = require("../abstract/Int");
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+const Int_1 = require("../abstract/Int");
 /**
  * @name UInt
  * @description
@@ -18,16 +12,16 @@ var _Int = require("../abstract/Int");
  * is available here.
  * @noInheritDoc
  */
-class UInt extends _Int.AbstractInt {
-  static with(bitLength, typeName) {
-    return class extends UInt {
-      constructor(registry, value) {
-        super(registry, value, bitLength);
-      }
-      toRawType() {
-        return typeName || super.toRawType();
-      }
-    };
-  }
+class UInt extends Int_1.AbstractInt {
+    static with(bitLength, typeName) {
+        return class extends UInt {
+            constructor(registry, value) {
+                super(registry, value, bitLength);
+            }
+            toRawType() {
+                return typeName || super.toRawType();
+            }
+        };
+    }
 }
 exports.UInt = UInt;

package/cjs/base/Vec.js

@@ -1,59 +1,59 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Vec = void 0;
-exports.decodeVec = decodeVec;
-var _util = require("@polkadot/util");
-var _Array = require("../abstract/Array");
-var _utils = require("../utils");
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+var _Vec_Type;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vec = exports.decodeVec = void 0;
+const tslib_1 = require("tslib");
+const util_1 = require("@polkadot/util");
+const Array_1 = require("../abstract/Array");
+const utils_1 = require("../utils");
 const MAX_LENGTH = 64 * 1024;
-const l = (0, _util.logger)('Vec');
+const l = (0, util_1.logger)('Vec');
 function noopSetDefinition(d) {
-  return d;
+    return d;
 }
 function decodeVecLength(value) {
-  if (Array.isArray(value)) {
-    return [value, value.length, 0];
-  } else if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
-    const u8a = (0, _util.u8aToU8a)(value);
-    const [startAt, length] = (0, _util.compactFromU8aLim)(u8a);
-    if (length > MAX_LENGTH) {
-      throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+    if (Array.isArray(value)) {
+        return [value, value.length, 0];
+    }
+    else if ((0, util_1.isU8a)(value) || (0, util_1.isHex)(value)) {
+        const u8a = (0, util_1.u8aToU8a)(value);
+        const [startAt, length] = (0, util_1.compactFromU8aLim)(u8a);
+        if (length > MAX_LENGTH) {
+            throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+        }
+        return [u8a, length, startAt];
+    }
+    else if (!value) {
+        return [null, 0, 0];
     }
-    return [u8a, length, startAt];
-  } else if (!value) {
-    return [null, 0, 0];
-  }
-  throw new Error(`Expected array/hex input to Vec<*> decoding, found ${typeof value}: ${(0, _util.stringify)(value)}`);
+    throw new Error(`Expected array/hex input to Vec<*> decoding, found ${typeof value}: ${(0, util_1.stringify)(value)}`);
 }
 function decodeVec(registry, result, value, startAt, Type) {
-  if (Array.isArray(value)) {
-    const count = result.length;
-    for (let i = 0; i < count; i++) {
-      // 26/08/2022 this is actually a false positive - after recent eslint upgdates
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      const entry = value[i];
-      try {
-        result[i] = entry instanceof Type ? entry : new Type(registry, entry);
-      } catch (error) {
-        l.error(`Unable to decode on index ${i}`, error.message);
-        throw error;
-      }
+    if (Array.isArray(value)) {
+        const count = result.length;
+        for (let i = 0; i < count; i++) {
+            // 26/08/2022 this is actually a false positive - after recent eslint upgdates
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const entry = value[i];
+            try {
+                result[i] = entry instanceof Type
+                    ? entry
+                    : new Type(registry, entry);
+            }
+            catch (error) {
+                l.error(`Unable to decode on index ${i}`, error.message);
+                throw error;
+            }
+        }
+        return [0, 0];
     }
-    return [0, 0];
-  } else if (!value) {
-    return [0, 0];
-  }
-
-  // we don't need more checks, we already limited it via the length decoding
-  return (0, _utils.decodeU8aVec)(registry, result, (0, _util.u8aToU8a)(value), startAt, Type);
+    else if (!value) {
+        return [0, 0];
+    }
+    // we don't need more checks, we already limited it via the length decoding
+    return (0, utils_1.decodeU8aVec)(registry, result, (0, util_1.u8aToU8a)(value), startAt, Type);
 }
-
+exports.decodeVec = decodeVec;
 /**
  * @name Vec
  * @description
@@ -61,60 +61,53 @@ function decodeVec(registry, result, value, startAt, Type) {
  * construction with the passed `Type` in the constructor. It is an extension to Array, providing
  * specific encoding/decoding on top of the base type.
  */
-class Vec extends _Array.AbstractArray {
-  #Type;
-  constructor(registry, Type) {
-    let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-    let {
-      definition,
-      setDefinition = noopSetDefinition
-    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-    const [decodeFrom, length, startAt] = decodeVecLength(value);
-    super(registry, length);
-    this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
-    this.initialU8aLength = ((0, _util.isU8a)(decodeFrom) ? (0, _utils.decodeU8aVec)(registry, this, decodeFrom, startAt, this.#Type) : decodeVec(registry, this, decodeFrom, startAt, this.#Type))[0];
-  }
-  static with(Type) {
-    let definition;
-
-    // eslint-disable-next-line no-return-assign
-    const setDefinition = d => definition = d;
-    return class extends Vec {
-      constructor(registry, value) {
-        super(registry, Type, value, {
-          definition,
-          setDefinition
-        });
-      }
-    };
-  }
-
-  /**
-   * @description The type for the items
-   */
-  get Type() {
-    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 other = _other instanceof this.#Type ? _other : new this.#Type(this.registry, _other);
-    for (let i = 0; i < this.length; i++) {
-      if (other.eq(this[i])) {
-        return i;
-      }
+class Vec extends Array_1.AbstractArray {
+    constructor(registry, Type, value = [], { definition, setDefinition = noopSetDefinition } = {}) {
+        const [decodeFrom, length, startAt] = decodeVecLength(value);
+        super(registry, length);
+        _Vec_Type.set(this, void 0);
+        tslib_1.__classPrivateFieldSet(this, _Vec_Type, definition || setDefinition((0, utils_1.typeToConstructor)(registry, Type)), "f");
+        this.initialU8aLength = ((0, util_1.isU8a)(decodeFrom)
+            ? (0, utils_1.decodeU8aVec)(registry, this, decodeFrom, startAt, tslib_1.__classPrivateFieldGet(this, _Vec_Type, "f"))
+            : decodeVec(registry, this, decodeFrom, startAt, tslib_1.__classPrivateFieldGet(this, _Vec_Type, "f")))[0];
+    }
+    static with(Type) {
+        let definition;
+        // eslint-disable-next-line no-return-assign
+        const setDefinition = (d) => (definition = d);
+        return class extends Vec {
+            constructor(registry, value) {
+                super(registry, Type, value, { definition, setDefinition });
+            }
+        };
+    }
+    /**
+     * @description The type for the items
+     */
+    get Type() {
+        return tslib_1.__classPrivateFieldGet(this, _Vec_Type, "f").name;
+    }
+    /**
+     * @description Finds the index of the value in the array
+     */
+    indexOf(_other) {
+        // convert type first, this removes overhead from the eq
+        const other = _other instanceof tslib_1.__classPrivateFieldGet(this, _Vec_Type, "f")
+            ? _other
+            : new (tslib_1.__classPrivateFieldGet(this, _Vec_Type, "f"))(this.registry, _other);
+        for (let i = 0; i < this.length; i++) {
+            if (other.eq(this[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return `Vec<${this.registry.getClassName(tslib_1.__classPrivateFieldGet(this, _Vec_Type, "f")) || new (tslib_1.__classPrivateFieldGet(this, _Vec_Type, "f"))(this.registry).toRawType()}>`;
     }
-    return -1;
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  toRawType() {
-    return `Vec<${this.registry.getClassName(this.#Type) || new this.#Type(this.registry).toRawType()}>`;
-  }
 }
-exports.Vec = Vec;
+exports.Vec = Vec;
+_Vec_Type = new WeakMap();

package/cjs/base/VecAny.js

@@ -1,13 +1,7 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.VecAny = void 0;
-var _Array = require("../abstract/Array");
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+const Array_1 = require("../abstract/Array");
 /**
  * @name VecAny
  * @description
@@ -15,13 +9,13 @@ var _Array = require("../abstract/Array");
  * a vector, this can be used to manage array-like structures with variable arguments of
  * any types
  */
-class VecAny extends _Array.AbstractArray {
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  toRawType() {
-    // FIXME This is basically an any type, cannot instantiate via createType
-    return 'Vec<Codec>';
-  }
+class VecAny extends Array_1.AbstractArray {
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        // FIXME This is basically an any type, cannot instantiate via createType
+        return 'Vec<Codec>';
+    }
 }
 exports.VecAny = VecAny;