@polkadot/types-codec 9.14.1 → 10.0.1

package/base/Result.js

@@ -1,76 +1,63 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { Enum } from "./Enum.js";
-
+import { Enum } from './Enum.js';
 /**
  * @name Result
  * @description
  * A Result maps to the Rust Result type, that can either wrap a success or error value
  */
 export class Result extends Enum {
-  constructor(registry, Ok, Err, value) {
-    // NOTE This is order-dependent, Ok (with index 0) needs to be first
-    // eslint-disable-next-line sort-keys
-    super(registry, {
-      Ok,
-      Err
-    }, value);
-  }
-  static with(Types) {
-    return class extends Result {
-      constructor(registry, value) {
-        super(registry, Types.Ok, Types.Err, value);
-      }
-    };
-  }
-
-  /**
-   * @description Returns the wrapper Err value (if isErr)
-   */
-  get asErr() {
-    if (!this.isErr) {
-      throw new Error('Cannot extract Err value from Ok result, check isErr first');
+    constructor(registry, Ok, Err, value) {
+        // NOTE This is order-dependent, Ok (with index 0) needs to be first
+        // eslint-disable-next-line sort-keys
+        super(registry, { Ok, Err }, value);
     }
-    return this.value;
-  }
-
-  /**
-   * @description Returns the wrapper Ok value (if isOk)
-   */
-  get asOk() {
-    if (!this.isOk) {
-      throw new Error('Cannot extract Ok value from Err result, check isOk first');
+    static with(Types) {
+        return class extends Result {
+            constructor(registry, value) {
+                super(registry, Types.Ok, Types.Err, value);
+            }
+        };
+    }
+    /**
+     * @description Returns the wrapper Err value (if isErr)
+     */
+    get asErr() {
+        if (!this.isErr) {
+            throw new Error('Cannot extract Err value from Ok result, check isErr first');
+        }
+        return this.value;
+    }
+    /**
+     * @description Returns the wrapper Ok value (if isOk)
+     */
+    get asOk() {
+        if (!this.isOk) {
+            throw new Error('Cannot extract Ok value from Err result, check isOk first');
+        }
+        return this.value;
+    }
+    /**
+     * @description Checks if the Result has no value
+     */
+    get isEmpty() {
+        return this.isOk && this.value.isEmpty;
+    }
+    /**
+     * @description Checks if the Result wraps an Err value
+     */
+    get isErr() {
+        return !this.isOk;
+    }
+    /**
+     * @description Checks if the Result wraps an Ok value
+     */
+    get isOk() {
+        return this.index === 0;
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        const Types = this._toRawStruct();
+        return `Result<${Types.Ok},${Types.Err}>`;
     }
-    return this.value;
-  }
-
-  /**
-   * @description Checks if the Result has no value
-   */
-  get isEmpty() {
-    return this.isOk && this.value.isEmpty;
-  }
-
-  /**
-   * @description Checks if the Result wraps an Err value
-   */
-  get isErr() {
-    return !this.isOk;
-  }
-
-  /**
-   * @description Checks if the Result wraps an Ok value
-   */
-  get isOk() {
-    return this.index === 0;
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  toRawType() {
-    const Types = this._toRawStruct();
-    return `Result<${Types.Ok},${Types.Err}>`;
-  }
 }

package/base/Tuple.js

@@ -1,38 +1,38 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { isFunction, isHex, isString, isU8a, stringify, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
-import { AbstractArray } from "../abstract/Array.js";
-import { decodeU8a, mapToTypeMap, typeToConstructor } from "../utils/index.js";
+import { AbstractArray } from '../abstract/Array.js';
+import { decodeU8a, mapToTypeMap, typeToConstructor } from '../utils/index.js';
 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 (isHex(value)) {
-    return decodeU8a(registry, result, 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 (isHex(value)) {
+        return decodeU8a(registry, result, u8aToU8a(value), Classes);
     }
-    return [result, 0];
-  }
-  throw new Error(`Expected array input to Tuple decoding, found ${typeof value}: ${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}: ${stringify(value)}`);
 }
-
 /**
  * @name Tuple
  * @description
@@ -40,79 +40,74 @@ function decodeTuple(registry, result, value, Classes) {
  * own type. It extends the base JS `Array` object.
  */
 export class Tuple extends AbstractArray {
-  #Types;
-  constructor(registry, Types, value, {
-    definition,
-    setDefinition = noopSetDefinition
-  } = {}) {
-    const Classes = definition || setDefinition(Array.isArray(Types) ? [Types.map(t => typeToConstructor(registry, t)), []] : isFunction(Types) || isString(Types) ? [[typeToConstructor(registry, Types)], []] : mapToTypeMap(registry, Types));
-    super(registry, Classes[0].length);
-    this.initialU8aLength = (isU8a(value) ? 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;
+    #Types;
+    constructor(registry, Types, value, { definition, setDefinition = noopSetDefinition } = {}) {
+        const Classes = definition || setDefinition(Array.isArray(Types)
+            ? [Types.map((t) => typeToConstructor(registry, t)), []]
+            : isFunction(Types) || isString(Types)
+                ? [[typeToConstructor(registry, Types)], []]
+                : mapToTypeMap(registry, Types));
+        super(registry, Classes[0].length);
+        this.initialU8aLength = (isU8a(value)
+            ? 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;
+        }
+        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 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 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 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 u8aConcatStrict(this.toU8aInner(isBare));
-  }
 }

package/base/UInt.js

@@ -1,8 +1,4 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { AbstractInt } from "../abstract/Int.js";
-
+import { AbstractInt } from '../abstract/Int.js';
 /**
  * @name UInt
  * @description
@@ -14,14 +10,14 @@ import { AbstractInt } from "../abstract/Int.js";
  * @noInheritDoc
  */
 export class UInt extends AbstractInt {
-  static with(bitLength, typeName) {
-    return class extends UInt {
-      constructor(registry, value) {
-        super(registry, value, bitLength);
-      }
-      toRawType() {
-        return typeName || super.toRawType();
-      }
-    };
-  }
+    static with(bitLength, typeName) {
+        return class extends UInt {
+            constructor(registry, value) {
+                super(registry, value, bitLength);
+            }
+            toRawType() {
+                return typeName || super.toRawType();
+            }
+        };
+    }
 }

package/base/Vec.js

@@ -1,52 +1,53 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { compactFromU8aLim, isHex, isU8a, logger, stringify, u8aToU8a } from '@polkadot/util';
-import { AbstractArray } from "../abstract/Array.js";
-import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
+import { AbstractArray } from '../abstract/Array.js';
+import { decodeU8aVec, typeToConstructor } from '../utils/index.js';
 const MAX_LENGTH = 64 * 1024;
 const l = logger('Vec');
 function noopSetDefinition(d) {
-  return d;
+    return d;
 }
 function decodeVecLength(value) {
-  if (Array.isArray(value)) {
-    return [value, value.length, 0];
-  } else if (isU8a(value) || isHex(value)) {
-    const u8a = u8aToU8a(value);
-    const [startAt, length] = 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];
     }
-    return [u8a, length, startAt];
-  } else if (!value) {
-    return [null, 0, 0];
-  }
-  throw new Error(`Expected array/hex input to Vec<*> decoding, found ${typeof value}: ${stringify(value)}`);
+    else if (isU8a(value) || isHex(value)) {
+        const u8a = u8aToU8a(value);
+        const [startAt, length] = 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];
+    }
+    throw new Error(`Expected array/hex input to Vec<*> decoding, found ${typeof value}: ${stringify(value)}`);
 }
 export 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 decodeU8aVec(registry, result, 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 decodeU8aVec(registry, result, u8aToU8a(value), startAt, Type);
 }
-
 /**
  * @name Vec
  * @description
@@ -55,56 +56,50 @@ export function decodeVec(registry, result, value, startAt, Type) {
  * specific encoding/decoding on top of the base type.
  */
 export class Vec extends AbstractArray {
-  #Type;
-  constructor(registry, Type, value = [], {
-    definition,
-    setDefinition = noopSetDefinition
-  } = {}) {
-    const [decodeFrom, length, startAt] = decodeVecLength(value);
-    super(registry, length);
-    this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
-    this.initialU8aLength = (isU8a(decodeFrom) ? 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;
-      }
+    #Type;
+    constructor(registry, Type, value = [], { definition, setDefinition = noopSetDefinition } = {}) {
+        const [decodeFrom, length, startAt] = decodeVecLength(value);
+        super(registry, length);
+        this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
+        this.initialU8aLength = (isU8a(decodeFrom)
+            ? 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;
+            }
+        }
+        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()}>`;
     }
-    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()}>`;
-  }
 }

package/base/VecAny.js

@@ -1,8 +1,4 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { AbstractArray } from "../abstract/Array.js";
-
+import { AbstractArray } from '../abstract/Array.js';
 /**
  * @name VecAny
  * @description
@@ -11,11 +7,11 @@ import { AbstractArray } from "../abstract/Array.js";
  * any types
  */
 export class VecAny extends 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>';
-  }
+    /**
+     * @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>';
+    }
 }