@polkadot/types-codec 9.14.2 → 10.0.1

package/base/VecFixed.js

@@ -1,81 +1,70 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { isU8a, u8aConcatStrict } from '@polkadot/util';
-import { AbstractArray } from "../abstract/Array.js";
-import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
-import { decodeVec } from "./Vec.js";
+import { AbstractArray } from '../abstract/Array.js';
+import { decodeU8aVec, typeToConstructor } from '../utils/index.js';
+import { decodeVec } from './Vec.js';
 function noopSetDefinition(d) {
-  return d;
+    return d;
 }
-
 /**
  * @name VecFixed
  * @description
  * This manages codec arrays of a fixed length
  */
 export class VecFixed extends AbstractArray {
-  #Type;
-  constructor(registry, Type, length, value = [], {
-    definition,
-    setDefinition = noopSetDefinition
-  } = {}) {
-    super(registry, length);
-    this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
-    this.initialU8aLength = (isU8a(value) ? decodeU8aVec(registry, this, value, 0, this.#Type) : decodeVec(registry, this, value, 0, this.#Type))[1];
-  }
-  static with(Type, length) {
-    let definition;
-
-    // eslint-disable-next-line no-return-assign
-    const setDefinition = d => definition = d;
-    return class extends VecFixed {
-      constructor(registry, value) {
-        super(registry, Type, length, value, {
-          definition,
-          setDefinition
-        });
-      }
-    };
-  }
-
-  /**
-   * @description The type for the items
-   */
-  get Type() {
-    return new this.#Type(this.registry).toRawType();
-  }
-
-  /**
-   * @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;
+    #Type;
+    constructor(registry, Type, length, value = [], { definition, setDefinition = noopSetDefinition } = {}) {
+        super(registry, length);
+        this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
+        this.initialU8aLength = (isU8a(value)
+            ? decodeU8aVec(registry, this, value, 0, this.#Type)
+            : decodeVec(registry, this, value, 0, this.#Type))[1];
+    }
+    static with(Type, length) {
+        let definition;
+        // eslint-disable-next-line no-return-assign
+        const setDefinition = (d) => (definition = d);
+        return class extends VecFixed {
+            constructor(registry, value) {
+                super(registry, Type, length, value, { definition, setDefinition });
+            }
+        };
+    }
+    /**
+     * @description The type for the items
+     */
+    get Type() {
+        return new this.#Type(this.registry).toRawType();
+    }
+    /**
+     * @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 Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return {
+            inner: this.inspectInner()
+        };
+    }
+    toU8a() {
+        // we override, we don't add the length prefix for ourselves, and at the same time we
+        // ignore isBare on entries, since they should be properly encoded at all times
+        const encoded = this.toU8aInner();
+        return encoded.length
+            ? u8aConcatStrict(encoded)
+            : new Uint8Array([]);
+    }
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType() {
+        return `[${this.Type};${this.length}]`;
     }
-    return total;
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  inspect() {
-    return {
-      inner: this.inspectInner()
-    };
-  }
-  toU8a() {
-    // we override, we don't add the length prefix for ourselves, and at the same time we
-    // ignore isBare on entries, since they should be properly encoded at all times
-    const encoded = this.toU8aInner();
-    return encoded.length ? u8aConcatStrict(encoded) : new Uint8Array([]);
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  toRawType() {
-    return `[${this.Type};${this.length}]`;
-  }
 }

package/base/index.js

@@ -1,15 +1,12 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export { Compact } from "./Compact.js";
-export { DoNotConstruct } from "./DoNotConstruct.js";
-export { Enum } from "./Enum.js";
-export { Int } from "./Int.js";
-export { Null } from "./Null.js";
-export { Option } from "./Option.js";
-export { Result } from "./Result.js";
-export { Tuple } from "./Tuple.js";
-export { UInt } from "./UInt.js";
-export { Vec } from "./Vec.js";
-export { VecAny } from "./VecAny.js";
-export { VecFixed } from "./VecFixed.js";
+export { Compact } from './Compact.js';
+export { DoNotConstruct } from './DoNotConstruct.js';
+export { Enum } from './Enum.js';
+export { Int } from './Int.js';
+export { Null } from './Null.js';
+export { Option } from './Option.js';
+export { Result } from './Result.js';
+export { Tuple } from './Tuple.js';
+export { UInt } from './UInt.js';
+export { Vec } from './Vec.js';
+export { VecAny } from './VecAny.js';
+export { VecFixed } from './VecFixed.js';

package/bundle.js

@@ -1,10 +1,7 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export { packageInfo } from "./packageInfo.js";
-export * from "./abstract/index.js";
-export * from "./base/index.js";
-export * from "./extended/index.js";
-export * from "./native/index.js";
-export * from "./primitive/index.js";
-export * from "./utils/index.js";
+export { packageInfo } from './packageInfo.js';
+export * from './abstract/index.js';
+export * from './base/index.js';
+export * from './extended/index.js';
+export * from './native/index.js';
+export * from './primitive/index.js';
+export * from './utils/index.js';

package/cjs/abstract/Array.js

@@ -1,14 +1,8 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractArray = void 0;
-var _util = require("@polkadot/util");
-var _compareArray = require("../utils/compareArray");
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
+const util_1 = require("@polkadot/util");
+const compareArray_1 = require("../utils/compareArray");
 /**
  * @name AbstractArray
  * @description
@@ -17,155 +11,140 @@ var _compareArray = require("../utils/compareArray");
  * @noInheritDoc
  */
 class AbstractArray extends Array {
-  /**
-   * @description This ensures that operators such as clice, filter, map, etc. return
-   * new Array instances (without this we need to apply overrides)
-   */
-  static get [Symbol.species]() {
-    return Array;
-  }
-  constructor(registry, length) {
-    super(length);
-    this.registry = registry;
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  get encodedLength() {
-    // We need to loop through all entries since they may have a variable length themselves,
-    // e.g. when a Vec or Compact is contained withing, it has a variable length based on data
-    let total = (0, _util.compactToU8a)(this.length).length;
-    for (let i = 0; i < this.length; i++) {
-      total += this[i].encodedLength;
-    }
-    return total;
-  }
-
-  /**
-   * @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.length === 0;
-  }
-
-  /**
-   * @description The length of the value
-   */
-  get length() {
-    // only included here since we ignore inherited docs
-    return super.length;
-  }
-
-  /**
-   * @description Compares the value of the input to see if there is a match
-   */
-  eq(other) {
-    return (0, _compareArray.compareArray)(this, other);
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  inspect() {
-    return {
-      inner: this.inspectInner(),
-      outer: [(0, _util.compactToU8a)(this.length)]
-    };
-  }
-  inspectInner() {
-    const inner = new Array(this.length);
-    for (let i = 0; i < this.length; i++) {
-      inner[i] = this[i].inspect();
-    }
-    return inner;
-  }
-
-  /**
-   * @description Converts the Object to an standard JavaScript Array
-   */
-  toArray() {
-    return Array.from(this);
-  }
-
-  /**
-   * @description Returns a hex string representation of the value
-   */
-  toHex() {
-    return (0, _util.u8aToHex)(this.toU8a());
-  }
-
-  /**
-   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-   */
-  toHuman(isExtended) {
-    const result = new Array(this.length);
-    for (let i = 0; i < this.length; i++) {
-      result[i] = this[i] && this[i].toHuman(isExtended);
-    }
-    return result;
-  }
-
-  /**
-   * @description Converts the Object to JSON, typically used for RPC transfers
-   */
-  toJSON() {
-    const result = new Array(this.length);
-    for (let i = 0; i < this.length; i++) {
-      // We actually log inside the U8a decoding and use JSON.stringify(...), which
-      // means that the Vec may be partially populated (same applies to toHuman, same check)
-      result[i] = this[i] && this[i].toJSON();
-    }
-    return result;
-  }
-
-  /**
-   * @description Converts the value in a best-fit primitive form
-   */
-  toPrimitive() {
-    const result = new Array(this.length);
-    for (let i = 0; i < this.length; i++) {
-      result[i] = this[i] && this[i].toPrimitive();
-    }
-    return result;
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-
-  /**
-   * @description Returns the string representation of the value
-   */
-  toString() {
-    const result = new Array(this.length);
-    for (let i = 0; i < this.length; i++) {
-      result[i] = this[i].toString();
-    }
-    return `[${result.join(', ')}]`;
-  }
-
-  /**
-   * @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) {
-    const encoded = this.toU8aInner();
-    return isBare ? (0, _util.u8aConcatStrict)(encoded) : (0, _util.u8aConcatStrict)([(0, _util.compactToU8a)(this.length), ...encoded]);
-  }
-  toU8aInner(isBare) {
-    const encoded = new Array(this.length);
-    for (let i = 0; i < this.length; i++) {
-      encoded[i] = this[i].toU8a(isBare);
-    }
-    return encoded;
-  }
+    /**
+     * @description This ensures that operators such as clice, filter, map, etc. return
+     * new Array instances (without this we need to apply overrides)
+     */
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(registry, length) {
+        super(length);
+        this.registry = registry;
+    }
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength() {
+        // We need to loop through all entries since they may have a variable length themselves,
+        // e.g. when a Vec or Compact is contained withing, it has a variable length based on data
+        let total = (0, util_1.compactToU8a)(this.length).length;
+        for (let i = 0; i < this.length; i++) {
+            total += this[i].encodedLength;
+        }
+        return total;
+    }
+    /**
+     * @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.length === 0;
+    }
+    /**
+     * @description The length of the value
+     */
+    get length() {
+        // only included here since we ignore inherited docs
+        return super.length;
+    }
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other) {
+        return (0, compareArray_1.compareArray)(this, other);
+    }
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect() {
+        return {
+            inner: this.inspectInner(),
+            outer: [(0, util_1.compactToU8a)(this.length)]
+        };
+    }
+    inspectInner() {
+        const inner = new Array(this.length);
+        for (let i = 0; i < this.length; i++) {
+            inner[i] = this[i].inspect();
+        }
+        return inner;
+    }
+    /**
+     * @description Converts the Object to an standard JavaScript Array
+     */
+    toArray() {
+        return Array.from(this);
+    }
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex() {
+        return (0, util_1.u8aToHex)(this.toU8a());
+    }
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended) {
+        const result = new Array(this.length);
+        for (let i = 0; i < this.length; i++) {
+            result[i] = this[i] && this[i].toHuman(isExtended);
+        }
+        return result;
+    }
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON() {
+        const result = new Array(this.length);
+        for (let i = 0; i < this.length; i++) {
+            // We actually log inside the U8a decoding and use JSON.stringify(...), which
+            // means that the Vec may be partially populated (same applies to toHuman, same check)
+            result[i] = this[i] && this[i].toJSON();
+        }
+        return result;
+    }
+    /**
+     * @description Converts the value in a best-fit primitive form
+     */
+    toPrimitive() {
+        const result = new Array(this.length);
+        for (let i = 0; i < this.length; i++) {
+            result[i] = this[i] && this[i].toPrimitive();
+        }
+        return result;
+    }
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString() {
+        const result = new Array(this.length);
+        for (let i = 0; i < this.length; i++) {
+            result[i] = this[i].toString();
+        }
+        return `[${result.join(', ')}]`;
+    }
+    /**
+     * @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) {
+        const encoded = this.toU8aInner();
+        return isBare
+            ? (0, util_1.u8aConcatStrict)(encoded)
+            : (0, util_1.u8aConcatStrict)([(0, util_1.compactToU8a)(this.length), ...encoded]);
+    }
+    toU8aInner(isBare) {
+        const encoded = new Array(this.length);
+        for (let i = 0; i < this.length; i++) {
+            encoded[i] = this[i].toU8a(isBare);
+        }
+        return encoded;
+    }
 }
 exports.AbstractArray = AbstractArray;