@polkadot/types-codec 6.12.2-2

package/extended/HashMap.js

@@ -0,0 +1,14 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { CodecMap } from "./Map.js";
+export class HashMap extends CodecMap {
+  static with(keyType, valType) {
+    return class extends HashMap {
+      constructor(registry, value) {
+        super(registry, keyType, valType, value);
+      }
+
+    };
+  }
+
+}

package/extended/Linkage.cjs

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LinkageResult = exports.Linkage = void 0;
+
+var _Option = require("../base/Option.cjs");
+
+var _Tuple = require("../base/Tuple.cjs");
+
+var _Vec = require("../base/Vec.cjs");
+
+var _Struct = require("../native/Struct.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+const EMPTY = new Uint8Array();
+/**
+ * @name Linkage
+ * @description The wrapper for the result from a LinkedMap
+ */
+
+class Linkage extends _Struct.Struct {
+  constructor(registry, Type, value) {
+    super(registry, {
+      previous: _Option.Option.with(Type),
+      // eslint-disable-next-line sort-keys
+      next: _Option.Option.with(Type)
+    }, value);
+  }
+
+  static withKey(Type) {
+    return class extends Linkage {
+      constructor(registry, value) {
+        super(registry, Type, value);
+      }
+
+    };
+  }
+
+  get previous() {
+    return this.get('previous');
+  }
+
+  get next() {
+    return this.get('next');
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `Linkage<${this.next.toRawType(true)}>`;
+  }
+  /**
+   * @description Custom toU8a which with bare mode does not return the linkage if empty
+   */
+
+
+  toU8a() {
+    // As part of a storage query (where these appear), in the case of empty, the values
+    // are NOT populated by the node - follow the same logic, leaving it empty
+    return this.isEmpty ? EMPTY : super.toU8a();
+  }
+
+}
+/**
+ * @name LinkageResult
+ * @description A Linkage keys/Values tuple
+ */
+
+
+exports.Linkage = Linkage;
+
+class LinkageResult extends _Tuple.Tuple {
+  constructor(registry, _ref, _ref2) {
+    let [TypeKey, keys] = _ref;
+    let [TypeValue, values] = _ref2;
+    super(registry, {
+      Keys: _Vec.Vec.with(TypeKey),
+      Values: _Vec.Vec.with(TypeValue)
+    }, [keys, values]);
+  }
+
+}
+
+exports.LinkageResult = LinkageResult;

package/extended/Linkage.d.ts

@@ -0,0 +1,31 @@
+import type { Codec, CodecClass, CodecRegistry } from '../types';
+import { Option } from '../base/Option';
+import { Tuple } from '../base/Tuple';
+import { Struct } from '../native/Struct';
+declare type TypeWithValues = [CodecClass, any[]];
+/**
+ * @name Linkage
+ * @description The wrapper for the result from a LinkedMap
+ */
+export declare class Linkage<T extends Codec> extends Struct {
+    constructor(registry: CodecRegistry, Type: CodecClass | string, value?: unknown);
+    static withKey<O extends Codec>(Type: CodecClass | string): CodecClass<Linkage<O>>;
+    get previous(): Option<T>;
+    get next(): Option<T>;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Custom toU8a which with bare mode does not return the linkage if empty
+     */
+    toU8a(): Uint8Array;
+}
+/**
+ * @name LinkageResult
+ * @description A Linkage keys/Values tuple
+ */
+export declare class LinkageResult extends Tuple {
+    constructor(registry: CodecRegistry, [TypeKey, keys]: TypeWithValues, [TypeValue, values]: TypeWithValues);
+}
+export {};

package/extended/Linkage.js

@@ -0,0 +1,71 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Option } from "../base/Option.js";
+import { Tuple } from "../base/Tuple.js";
+import { Vec } from "../base/Vec.js";
+import { Struct } from "../native/Struct.js";
+const EMPTY = new Uint8Array();
+/**
+ * @name Linkage
+ * @description The wrapper for the result from a LinkedMap
+ */
+
+export class Linkage extends Struct {
+  constructor(registry, Type, value) {
+    super(registry, {
+      previous: Option.with(Type),
+      // eslint-disable-next-line sort-keys
+      next: Option.with(Type)
+    }, value);
+  }
+
+  static withKey(Type) {
+    return class extends Linkage {
+      constructor(registry, value) {
+        super(registry, Type, value);
+      }
+
+    };
+  }
+
+  get previous() {
+    return this.get('previous');
+  }
+
+  get next() {
+    return this.get('next');
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `Linkage<${this.next.toRawType(true)}>`;
+  }
+  /**
+   * @description Custom toU8a which with bare mode does not return the linkage if empty
+   */
+
+
+  toU8a() {
+    // As part of a storage query (where these appear), in the case of empty, the values
+    // are NOT populated by the node - follow the same logic, leaving it empty
+    return this.isEmpty ? EMPTY : super.toU8a();
+  }
+
+}
+/**
+ * @name LinkageResult
+ * @description A Linkage keys/Values tuple
+ */
+
+export class LinkageResult extends Tuple {
+  constructor(registry, [TypeKey, keys], [TypeValue, values]) {
+    super(registry, {
+      Keys: Vec.with(TypeKey),
+      Values: Vec.with(TypeValue)
+    }, [keys, values]);
+  }
+
+}

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;
+}