@polkadot/types-codec 6.12.2-2

package/abstract/AbstractArray.cjs

@@ -0,0 +1,208 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbstractArray = void 0;
+
+var _util = require("@polkadot/util");
+
+var _compareArray = require("../utils/compareArray.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name AbstractArray
+ * @description
+ * This manages codec arrays. It is an extension to Array, providing
+ * specific encoding/decoding on top of the base type.
+ * @noInheritDoc
+ */
+class AbstractArray extends Array {
+  constructor(registry, values, initialU8aLength) {
+    super(values.length); // explicitly set the values here - this removes the need for any extra allocations
+
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    this.initialU8aLength = void 0;
+
+    for (let i = 0; i < values.length; i++) {
+      this[i] = values[i];
+    }
+
+    this.registry = registry;
+    this.initialU8aLength = initialU8aLength;
+  }
+  /**
+   * @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 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].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++) {
+      result[i] = this[i].toJSON();
+    }
+
+    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 = new Array(this.length);
+
+    for (let i = 0; i < this.length; i++) {
+      encoded[i] = this[i].toU8a(isBare);
+    }
+
+    return isBare ? (0, _util.u8aConcat)(...encoded) : (0, _util.u8aConcat)((0, _util.compactToU8a)(this.length), ...encoded);
+  } // Below are methods that we override. When we do a `new Vec(...).map()`,
+  // we want it to return an Array. We only override the methods that return a
+  // new instance.
+
+  /**
+   * @description Concatenates two arrays
+   */
+
+
+  concat(other) {
+    return this.toArray().concat(other instanceof AbstractArray ? other.toArray() : other);
+  }
+  /**
+   * @description Filters the array with the callback
+   */
+
+
+  filter(callbackfn, thisArg) {
+    return this.toArray().filter(callbackfn, thisArg);
+  }
+  /**
+   * @description Maps the array with the callback
+   */
+
+
+  map(callbackfn, thisArg) {
+    return this.toArray().map(callbackfn, thisArg);
+  }
+  /**
+   * @description Checks if the array includes a specific value
+   */
+
+
+  includes(check) {
+    return this.some(value => value.eq(check));
+  }
+  /**
+   * @description Returns a slice of an array
+   */
+
+
+  slice(start, end) {
+    return this.toArray().slice(start, end);
+  }
+
+}
+
+exports.AbstractArray = AbstractArray;

package/abstract/AbstractArray.d.ts

@@ -0,0 +1,84 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson, Codec, CodecRegistry, IU8a, IVec } from '../types';
+/**
+ * @name AbstractArray
+ * @description
+ * This manages codec arrays. It is an extension to Array, providing
+ * specific encoding/decoding on top of the base type.
+ * @noInheritDoc
+ */
+export declare abstract class AbstractArray<T extends Codec> extends Array<T> implements IVec<T> {
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    readonly initialU8aLength?: number;
+    protected constructor(registry: CodecRegistry, values: T[], initialU8aLength?: number);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash(): IU8a;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description The length of the value
+     */
+    get length(): number;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Converts the Object to an standard JavaScript Array
+     */
+    toArray(): T[];
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex(): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended?: boolean): AnyJson;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): AnyJson;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    abstract toRawType(): string;
+    /**
+     * @description Returns the string representation of the value
+     */
+    toString(): string;
+    /**
+     * @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?: boolean): Uint8Array;
+    /**
+     * @description Concatenates two arrays
+     */
+    concat(other: T[]): T[];
+    /**
+     * @description Filters the array with the callback
+     */
+    filter(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: unknown): T[];
+    /**
+     * @description Maps the array with the callback
+     */
+    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: unknown): U[];
+    /**
+     * @description Checks if the array includes a specific value
+     */
+    includes(check: unknown): boolean;
+    /**
+     * @description Returns a slice of an array
+     */
+    slice(start?: number, end?: number): T[];
+}

package/abstract/AbstractArray.js

@@ -0,0 +1,197 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { compactToU8a, u8aConcat, u8aToHex } from '@polkadot/util';
+import { compareArray } from "../utils/compareArray.js";
+/**
+ * @name AbstractArray
+ * @description
+ * This manages codec arrays. It is an extension to Array, providing
+ * specific encoding/decoding on top of the base type.
+ * @noInheritDoc
+ */
+
+export class AbstractArray extends Array {
+  constructor(registry, values, initialU8aLength) {
+    super(values.length); // explicitly set the values here - this removes the need for any extra allocations
+
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    this.initialU8aLength = void 0;
+
+    for (let i = 0; i < values.length; i++) {
+      this[i] = values[i];
+    }
+
+    this.registry = registry;
+    this.initialU8aLength = initialU8aLength;
+  }
+  /**
+   * @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 = 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 compareArray(this, other);
+  }
+  /**
+   * @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 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].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++) {
+      result[i] = this[i].toJSON();
+    }
+
+    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 = new Array(this.length);
+
+    for (let i = 0; i < this.length; i++) {
+      encoded[i] = this[i].toU8a(isBare);
+    }
+
+    return isBare ? u8aConcat(...encoded) : u8aConcat(compactToU8a(this.length), ...encoded);
+  } // Below are methods that we override. When we do a `new Vec(...).map()`,
+  // we want it to return an Array. We only override the methods that return a
+  // new instance.
+
+  /**
+   * @description Concatenates two arrays
+   */
+
+
+  concat(other) {
+    return this.toArray().concat(other instanceof AbstractArray ? other.toArray() : other);
+  }
+  /**
+   * @description Filters the array with the callback
+   */
+
+
+  filter(callbackfn, thisArg) {
+    return this.toArray().filter(callbackfn, thisArg);
+  }
+  /**
+   * @description Maps the array with the callback
+   */
+
+
+  map(callbackfn, thisArg) {
+    return this.toArray().map(callbackfn, thisArg);
+  }
+  /**
+   * @description Checks if the array includes a specific value
+   */
+
+
+  includes(check) {
+    return this.some(value => value.eq(check));
+  }
+  /**
+   * @description Returns a slice of an array
+   */
+
+
+  slice(start, end) {
+    return this.toArray().slice(start, end);
+  }
+
+}