@polkadot/types-codec 6.12.2-10

package/extended/Map.cjs

@@ -0,0 +1,244 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CodecMap = void 0;
+
+var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+
+var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+
+var _util = require("@polkadot/util");
+
+var _AbstractArray = require("../abstract/AbstractArray.cjs");
+
+var _Enum = require("../base/Enum.cjs");
+
+var _Struct = require("../native/Struct.cjs");
+
+var _index = require("../utils/index.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+const l = (0, _util.logger)('Map');
+/** @internal */
+
+function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
+  const output = new Map();
+  const [offset, length] = (0, _util.compactFromU8a)(u8a);
+  const count = length.toNumber();
+  const types = [];
+
+  for (let i = 0; i < count; i++) {
+    types.push(KeyClass, ValClass);
+  }
+
+  const [values, decodedLength] = (0, _index.decodeU8a)(registry, u8a.subarray(offset), types);
+
+  for (let i = 0; i < values.length; i += 2) {
+    output.set(values[i], values[i + 1]);
+  }
+
+  return [output, offset + decodedLength];
+}
+/** @internal */
+
+
+function decodeMapFromMap(registry, KeyClass, ValClass, value) {
+  const output = new Map();
+
+  for (const [key, val] of value.entries()) {
+    const isComplex = KeyClass.prototype instanceof _AbstractArray.AbstractArray || KeyClass.prototype instanceof _Struct.Struct || KeyClass.prototype instanceof _Enum.Enum;
+
+    try {
+      output.set(key instanceof KeyClass ? key : new KeyClass(registry, isComplex ? JSON.parse(key) : key), val instanceof ValClass ? val : new ValClass(registry, val));
+    } catch (error) {
+      l.error('Failed to decode key or value:', error.message);
+      throw error;
+    }
+  }
+
+  return [output, 0];
+}
+/**
+ * Decode input to pass into constructor.
+ *
+ * @param KeyClass - Type of the map key
+ * @param ValClass - Type of the map value
+ * @param value - Value to decode, one of:
+ * - null
+ * - undefined
+ * - hex
+ * - Uint8Array
+ * - Map<any, any>, where both key and value types are either
+ *   constructors or decodeable values for their types.
+ * @param jsonMap
+ * @internal
+ */
+
+
+function decodeMap(registry, keyType, valType, value) {
+  const KeyClass = (0, _index.typeToConstructor)(registry, keyType);
+  const ValClass = (0, _index.typeToConstructor)(registry, valType);
+
+  if (!value) {
+    return [new Map(), 0];
+  } else if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
+    return decodeMapFromU8a(registry, KeyClass, ValClass, (0, _util.u8aToU8a)(value));
+  } else if (value instanceof Map) {
+    return decodeMapFromMap(registry, KeyClass, ValClass, value);
+  } else if ((0, _util.isObject)(value)) {
+    return decodeMapFromMap(registry, KeyClass, ValClass, new Map(Object.entries(value)));
+  }
+
+  throw new Error('Map: cannot decode type');
+}
+
+var _KeyClass = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("KeyClass");
+
+var _ValClass = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("ValClass");
+
+var _type = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("type");
+
+class CodecMap extends Map {
+  constructor(registry, keyType, valType, rawValue) {
+    let type = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'HashMap';
+    const [decoded, decodedLength] = decodeMap(registry, keyType, valType, rawValue);
+    super(type === 'BTreeMap' ? (0, _index.sortMap)(decoded) : decoded);
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    Object.defineProperty(this, _KeyClass, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _ValClass, {
+      writable: true,
+      value: void 0
+    });
+    this.initialU8aLength = void 0;
+    Object.defineProperty(this, _type, {
+      writable: true,
+      value: void 0
+    });
+    this.registry = registry;
+    this.initialU8aLength = decodedLength;
+    (0, _classPrivateFieldLooseBase2.default)(this, _KeyClass)[_KeyClass] = (0, _index.typeToConstructor)(registry, keyType);
+    (0, _classPrivateFieldLooseBase2.default)(this, _ValClass)[_ValClass] = (0, _index.typeToConstructor)(registry, valType);
+    (0, _classPrivateFieldLooseBase2.default)(this, _type)[_type] = type;
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    let len = (0, _util.compactToU8a)(this.size).length;
+
+    for (const [k, v] of this.entries()) {
+      len += v.encodedLength + k.encodedLength;
+    }
+
+    return len;
+  }
+  /**
+   * @description Returns a hash of the value
+   */
+
+
+  get hash() {
+    return this.registry.hash(this.toU8a());
+  }
+  /**
+   * @description Checks if the value is an empty value
+   */
+
+
+  get isEmpty() {
+    return this.size === 0;
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return (0, _index.compareMap)(this, other);
+  }
+  /**
+   * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+   */
+
+
+  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 json = {};
+
+    for (const [k, v] of this.entries()) {
+      json[k.toString()] = v.toHuman(isExtended);
+    }
+
+    return json;
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    const json = {};
+
+    for (const [k, v] of this.entries()) {
+      json[k.toString()] = v.toJSON();
+    }
+
+    return json;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `${(0, _classPrivateFieldLooseBase2.default)(this, _type)[_type]}<${this.registry.getClassName((0, _classPrivateFieldLooseBase2.default)(this, _KeyClass)[_KeyClass]) || new ((0, _classPrivateFieldLooseBase2.default)(this, _KeyClass)[_KeyClass])(this.registry).toRawType()},${this.registry.getClassName((0, _classPrivateFieldLooseBase2.default)(this, _ValClass)[_ValClass]) || new ((0, _classPrivateFieldLooseBase2.default)(this, _ValClass)[_ValClass])(this.registry).toRawType()}>`;
+  }
+  /**
+   * @description Returns the string representation of the value
+   */
+
+
+  toString() {
+    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) {
+    const encoded = new Array();
+
+    if (!isBare) {
+      encoded.push((0, _util.compactToU8a)(this.size));
+    }
+
+    for (const [k, v] of this.entries()) {
+      encoded.push(k.toU8a(isBare), v.toU8a(isBare));
+    }
+
+    return (0, _util.u8aConcat)(...encoded);
+  }
+
+}
+
+exports.CodecMap = CodecMap;

package/extended/Map.d.ts

@@ -0,0 +1,50 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson, Codec, CodecClass, CodecRegistry, IMap, IU8a } from '../types';
+export declare class CodecMap<K extends Codec = Codec, V extends Codec = Codec> extends Map<K, V> implements IMap<K, V> {
+    #private;
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    readonly initialU8aLength?: number;
+    constructor(registry: CodecRegistry, keyType: CodecClass<K> | string, valType: CodecClass<V> | string, rawValue: Uint8Array | string | Map<any, any> | undefined, type?: 'BTreeMap' | 'HashMap');
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description Returns a hash of the value
+     */
+    get hash(): IU8a;
+    /**
+     * @description Checks if the value is an empty value
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+     */
+    toHex(): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExtended?: boolean): Record<string, AnyJson>;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): Record<string, AnyJson>;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    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;
+}

package/extended/Map.js

@@ -0,0 +1,225 @@
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/esm/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/esm/classPrivateFieldLooseKey";
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { compactFromU8a, compactToU8a, isHex, isObject, isU8a, logger, stringify, u8aConcat, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { AbstractArray } from "../abstract/AbstractArray.js";
+import { Enum } from "../base/Enum.js";
+import { Struct } from "../native/Struct.js";
+import { compareMap, decodeU8a, sortMap, typeToConstructor } from "../utils/index.js";
+const l = logger('Map');
+/** @internal */
+
+function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
+  const output = new Map();
+  const [offset, length] = compactFromU8a(u8a);
+  const count = length.toNumber();
+  const types = [];
+
+  for (let i = 0; i < count; i++) {
+    types.push(KeyClass, ValClass);
+  }
+
+  const [values, decodedLength] = decodeU8a(registry, u8a.subarray(offset), types);
+
+  for (let i = 0; i < values.length; i += 2) {
+    output.set(values[i], values[i + 1]);
+  }
+
+  return [output, offset + decodedLength];
+}
+/** @internal */
+
+
+function decodeMapFromMap(registry, KeyClass, ValClass, value) {
+  const output = new Map();
+
+  for (const [key, val] of value.entries()) {
+    const isComplex = KeyClass.prototype instanceof AbstractArray || KeyClass.prototype instanceof Struct || KeyClass.prototype instanceof Enum;
+
+    try {
+      output.set(key instanceof KeyClass ? key : new KeyClass(registry, isComplex ? JSON.parse(key) : key), val instanceof ValClass ? val : new ValClass(registry, val));
+    } catch (error) {
+      l.error('Failed to decode key or value:', error.message);
+      throw error;
+    }
+  }
+
+  return [output, 0];
+}
+/**
+ * Decode input to pass into constructor.
+ *
+ * @param KeyClass - Type of the map key
+ * @param ValClass - Type of the map value
+ * @param value - Value to decode, one of:
+ * - null
+ * - undefined
+ * - hex
+ * - Uint8Array
+ * - Map<any, any>, where both key and value types are either
+ *   constructors or decodeable values for their types.
+ * @param jsonMap
+ * @internal
+ */
+
+
+function decodeMap(registry, keyType, valType, value) {
+  const KeyClass = typeToConstructor(registry, keyType);
+  const ValClass = typeToConstructor(registry, valType);
+
+  if (!value) {
+    return [new Map(), 0];
+  } else if (isU8a(value) || isHex(value)) {
+    return decodeMapFromU8a(registry, KeyClass, ValClass, u8aToU8a(value));
+  } else if (value instanceof Map) {
+    return decodeMapFromMap(registry, KeyClass, ValClass, value);
+  } else if (isObject(value)) {
+    return decodeMapFromMap(registry, KeyClass, ValClass, new Map(Object.entries(value)));
+  }
+
+  throw new Error('Map: cannot decode type');
+}
+
+var _KeyClass = /*#__PURE__*/_classPrivateFieldLooseKey("KeyClass");
+
+var _ValClass = /*#__PURE__*/_classPrivateFieldLooseKey("ValClass");
+
+var _type = /*#__PURE__*/_classPrivateFieldLooseKey("type");
+
+export class CodecMap extends Map {
+  constructor(registry, keyType, valType, rawValue, type = 'HashMap') {
+    const [decoded, decodedLength] = decodeMap(registry, keyType, valType, rawValue);
+    super(type === 'BTreeMap' ? sortMap(decoded) : decoded);
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    Object.defineProperty(this, _KeyClass, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _ValClass, {
+      writable: true,
+      value: void 0
+    });
+    this.initialU8aLength = void 0;
+    Object.defineProperty(this, _type, {
+      writable: true,
+      value: void 0
+    });
+    this.registry = registry;
+    this.initialU8aLength = decodedLength;
+    _classPrivateFieldLooseBase(this, _KeyClass)[_KeyClass] = typeToConstructor(registry, keyType);
+    _classPrivateFieldLooseBase(this, _ValClass)[_ValClass] = typeToConstructor(registry, valType);
+    _classPrivateFieldLooseBase(this, _type)[_type] = type;
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    let len = compactToU8a(this.size).length;
+
+    for (const [k, v] of this.entries()) {
+      len += v.encodedLength + k.encodedLength;
+    }
+
+    return len;
+  }
+  /**
+   * @description Returns a hash of the value
+   */
+
+
+  get hash() {
+    return this.registry.hash(this.toU8a());
+  }
+  /**
+   * @description Checks if the value is an empty value
+   */
+
+
+  get isEmpty() {
+    return this.size === 0;
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return compareMap(this, other);
+  }
+  /**
+   * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
+   */
+
+
+  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 json = {};
+
+    for (const [k, v] of this.entries()) {
+      json[k.toString()] = v.toHuman(isExtended);
+    }
+
+    return json;
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    const json = {};
+
+    for (const [k, v] of this.entries()) {
+      json[k.toString()] = v.toJSON();
+    }
+
+    return json;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `${_classPrivateFieldLooseBase(this, _type)[_type]}<${this.registry.getClassName(_classPrivateFieldLooseBase(this, _KeyClass)[_KeyClass]) || new (_classPrivateFieldLooseBase(this, _KeyClass)[_KeyClass])(this.registry).toRawType()},${this.registry.getClassName(_classPrivateFieldLooseBase(this, _ValClass)[_ValClass]) || new (_classPrivateFieldLooseBase(this, _ValClass)[_ValClass])(this.registry).toRawType()}>`;
+  }
+  /**
+   * @description Returns the string representation of the value
+   */
+
+
+  toString() {
+    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) {
+    const encoded = new Array();
+
+    if (!isBare) {
+      encoded.push(compactToU8a(this.size));
+    }
+
+    for (const [k, v] of this.entries()) {
+      encoded.push(k.toU8a(isBare), v.toU8a(isBare));
+    }
+
+    return u8aConcat(...encoded);
+  }
+
+}

package/extended/Range.cjs

@@ -0,0 +1,92 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RangeInclusive = exports.Range = void 0;
+
+var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+
+var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+
+var _Tuple = require("../base/Tuple.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+var _rangeName = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("rangeName");
+
+/**
+ * @name Range
+ * @description
+ * Rust `Range<T>` representation
+ */
+class Range extends _Tuple.Tuple {
+  constructor(registry, Type, value) {
+    let rangeName = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'Range';
+    super(registry, {
+      end: Type,
+      start: Type
+    }, value);
+    Object.defineProperty(this, _rangeName, {
+      writable: true,
+      value: void 0
+    });
+    (0, _classPrivateFieldLooseBase2.default)(this, _rangeName)[_rangeName] = rangeName;
+  }
+
+  static with(Types) {
+    return class extends Range {
+      constructor(registry, value) {
+        super(registry, Types, value);
+      }
+
+    };
+  }
+  /**
+   * @description Returns the starting range value
+   */
+
+
+  get start() {
+    return this[0];
+  }
+  /**
+   * @description Returns the ending range value
+   */
+
+
+  get end() {
+    return this[1];
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `${(0, _classPrivateFieldLooseBase2.default)(this, _rangeName)[_rangeName]}<${this.start.toRawType()}>`;
+  }
+
+}
+
+exports.Range = Range;
+
+class RangeInclusive extends Range {
+  constructor(registry, type, value) {
+    super(registry, type, value, 'RangeInclusive');
+  }
+
+  static with(Types) {
+    return class extends RangeInclusive {
+      constructor(registry, value) {
+        super(registry, Types, value);
+      }
+
+    };
+  }
+
+}
+
+exports.RangeInclusive = RangeInclusive;

package/extended/Range.d.ts

@@ -0,0 +1,30 @@
+import type { AnyTuple, CodecClass, CodecRegistry, INumber } from '../types';
+import { Tuple } from '../base/Tuple';
+declare type RangeType = 'Range' | 'RangeInclusive';
+/**
+ * @name Range
+ * @description
+ * Rust `Range<T>` representation
+ */
+export declare class Range<T extends INumber> extends Tuple {
+    #private;
+    constructor(registry: CodecRegistry, Type: CodecClass<T> | string, value?: AnyTuple, rangeName?: RangeType);
+    static with<T extends INumber>(Types: CodecClass<T> | string): CodecClass<Range<T>>;
+    /**
+     * @description Returns the starting range value
+     */
+    get start(): T;
+    /**
+     * @description Returns the ending range value
+     */
+    get end(): T;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+}
+export declare class RangeInclusive<T extends INumber = INumber> extends Range<T> {
+    constructor(registry: CodecRegistry, type: CodecClass<T> | string, value?: AnyTuple);
+    static with<T extends INumber>(Types: CodecClass<T> | string): CodecClass<RangeInclusive<T>>;
+}
+export {};