@polkadot/types-codec 6.12.2-10

package/base/index.js

@@ -0,0 +1,15 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export { Base } from "./Base.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.cjs

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  packageInfo: true
+};
+Object.defineProperty(exports, "packageInfo", {
+  enumerable: true,
+  get: function () {
+    return _packageInfo.packageInfo;
+  }
+});
+
+var _packageInfo = require("./packageInfo.cjs");
+
+var _index = require("./abstract/index.cjs");
+
+Object.keys(_index).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _index[key];
+    }
+  });
+});
+
+var _index2 = require("./base/index.cjs");
+
+Object.keys(_index2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _index2[key];
+    }
+  });
+});
+
+var _index3 = require("./extended/index.cjs");
+
+Object.keys(_index3).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index3[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _index3[key];
+    }
+  });
+});
+
+var _index4 = require("./native/index.cjs");
+
+Object.keys(_index4).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index4[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _index4[key];
+    }
+  });
+});
+
+var _index5 = require("./primitive/index.cjs");
+
+Object.keys(_index5).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index5[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _index5[key];
+    }
+  });
+});
+
+var _index6 = require("./utils/index.cjs");
+
+Object.keys(_index6).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index6[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _index6[key];
+    }
+  });
+});

package/bundle.d.ts

@@ -0,0 +1,7 @@
+export { packageInfo } from './packageInfo';
+export * from './abstract';
+export * from './base';
+export * from './extended';
+export * from './native';
+export * from './primitive';
+export * from './utils';

package/bundle.js

@@ -0,0 +1,9 @@
+// Copyright 2017-2021 @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";

package/detectPackage.cjs

@@ -0,0 +1,9 @@
+"use strict";
+
+var _util = require("@polkadot/util");
+
+var _packageInfo = require("./packageInfo.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+(0, _util.detectPackage)(_packageInfo.packageInfo, typeof __dirname !== 'undefined' && __dirname, []);

package/detectPackage.d.ts

@@ -0,0 +1 @@
+export {};

package/detectPackage.js

@@ -0,0 +1,5 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { detectPackage } from '@polkadot/util';
+import { packageInfo } from "./packageInfo.js";
+detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname, []);

package/extended/BTreeMap.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BTreeMap = void 0;
+
+var _Map = require("./Map.cjs");
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+class BTreeMap extends _Map.CodecMap {
+  static with(keyType, valType) {
+    return class extends BTreeMap {
+      constructor(registry, value) {
+        super(registry, keyType, valType, value, 'BTreeMap');
+      }
+
+    };
+  }
+
+}
+
+exports.BTreeMap = BTreeMap;

package/extended/BTreeMap.d.ts

@@ -0,0 +1,5 @@
+import type { Codec, CodecClass } from '../types';
+import { CodecMap } from './Map';
+export declare class BTreeMap<K extends Codec = Codec, V extends Codec = Codec> extends CodecMap<K, V> {
+    static with<K extends Codec, V extends Codec>(keyType: CodecClass<K> | string, valType: CodecClass<V> | string): CodecClass<CodecMap<K, V>>;
+}

package/extended/BTreeMap.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 BTreeMap extends CodecMap {
+  static with(keyType, valType) {
+    return class extends BTreeMap {
+      constructor(registry, value) {
+        super(registry, keyType, valType, value, 'BTreeMap');
+      }
+
+    };
+  }
+
+}

package/extended/BTreeSet.cjs

@@ -0,0 +1,227 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BTreeSet = void 0;
+
+var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+
+var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+
+var _util = require("@polkadot/util");
+
+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)('BTreeSet');
+/** @internal */
+
+function decodeSetFromU8a(registry, ValClass, u8a) {
+  const output = new Set();
+  const [offset, length] = (0, _util.compactFromU8a)(u8a);
+  const [values, decodedLength] = (0, _index.decodeU8aVec)(registry, u8a, offset, ValClass, length.toNumber());
+
+  for (let i = 0; i < values.length; i++) {
+    output.add(values[i]);
+  }
+
+  return [output, decodedLength + offset];
+}
+/** @internal */
+
+
+function decodeSetFromSet(registry, ValClass, value) {
+  const output = new Set();
+  value.forEach(val => {
+    try {
+      output.add(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 ValClass - Type of the map value
+ * @param value - Value to decode, one of:
+ * - null
+ * - undefined
+ * - hex
+ * - Uint8Array
+ * - Set<any>, where both key and value types are either
+ *   constructors or decodeable values for their types.
+ * @param jsonSet
+ * @internal
+ */
+
+
+function decodeSet(registry, valType, value) {
+  if (!value) {
+    return [new Set(), 0];
+  }
+
+  const ValClass = (0, _index.typeToConstructor)(registry, valType);
+
+  if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
+    return decodeSetFromU8a(registry, ValClass, (0, _util.u8aToU8a)(value));
+  } else if (Array.isArray(value) || value instanceof Set) {
+    return decodeSetFromSet(registry, ValClass, value);
+  }
+
+  throw new Error('BTreeSet: cannot decode type');
+}
+
+var _ValClass = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("ValClass");
+
+class BTreeSet extends Set {
+  constructor(registry, valType, rawValue) {
+    const [values, decodedLength] = decodeSet(registry, valType, rawValue);
+    super((0, _index.sortSet)(values));
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    this.initialU8aLength = void 0;
+    Object.defineProperty(this, _ValClass, {
+      writable: true,
+      value: void 0
+    });
+    this.registry = registry;
+    this.initialU8aLength = decodedLength;
+    (0, _classPrivateFieldLooseBase2.default)(this, _ValClass)[_ValClass] = (0, _index.typeToConstructor)(registry, valType);
+  }
+
+  static with(valType) {
+    return class extends BTreeSet {
+      constructor(registry, value) {
+        super(registry, valType, value);
+      }
+
+    };
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    let len = (0, _util.compactToU8a)(this.size).length;
+
+    for (const v of this.values()) {
+      len += v.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 The actual set values as a string[]
+   */
+
+
+  get strings() {
+    return [...super.values()].map(v => v.toString());
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return (0, _index.compareSet)(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 v of this.values()) {
+      json.push(v.toHuman(isExtended));
+    }
+
+    return json;
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    const json = [];
+
+    for (const v of this.values()) {
+      json.push(v.toJSON());
+    }
+
+    return json;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `BTreeSet<${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 v of this.values()) {
+      encoded.push(v.toU8a(isBare));
+    }
+
+    return (0, _util.u8aConcat)(...encoded);
+  }
+
+}
+
+exports.BTreeSet = BTreeSet;

package/extended/BTreeSet.d.ts

@@ -0,0 +1,55 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyJson, Codec, CodecClass, CodecRegistry, ISet, IU8a } from '../types';
+export declare class BTreeSet<V extends Codec = Codec> extends Set<V> implements ISet<V> {
+    #private;
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    readonly initialU8aLength?: number;
+    constructor(registry: CodecRegistry, valType: CodecClass<V> | string, rawValue?: Uint8Array | string | string[] | Set<any>);
+    static with<V extends Codec>(valType: CodecClass<V> | string): CodecClass<BTreeSet<V>>;
+    /**
+     * @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 The actual set values as a string[]
+     */
+    get strings(): string[];
+    /**
+     * @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): AnyJson;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(): 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/BTreeSet.js

@@ -0,0 +1,212 @@
+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, isU8a, logger, stringify, u8aConcat, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { compareSet, decodeU8aVec, sortSet, typeToConstructor } from "../utils/index.js";
+const l = logger('BTreeSet');
+/** @internal */
+
+function decodeSetFromU8a(registry, ValClass, u8a) {
+  const output = new Set();
+  const [offset, length] = compactFromU8a(u8a);
+  const [values, decodedLength] = decodeU8aVec(registry, u8a, offset, ValClass, length.toNumber());
+
+  for (let i = 0; i < values.length; i++) {
+    output.add(values[i]);
+  }
+
+  return [output, decodedLength + offset];
+}
+/** @internal */
+
+
+function decodeSetFromSet(registry, ValClass, value) {
+  const output = new Set();
+  value.forEach(val => {
+    try {
+      output.add(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 ValClass - Type of the map value
+ * @param value - Value to decode, one of:
+ * - null
+ * - undefined
+ * - hex
+ * - Uint8Array
+ * - Set<any>, where both key and value types are either
+ *   constructors or decodeable values for their types.
+ * @param jsonSet
+ * @internal
+ */
+
+
+function decodeSet(registry, valType, value) {
+  if (!value) {
+    return [new Set(), 0];
+  }
+
+  const ValClass = typeToConstructor(registry, valType);
+
+  if (isU8a(value) || isHex(value)) {
+    return decodeSetFromU8a(registry, ValClass, u8aToU8a(value));
+  } else if (Array.isArray(value) || value instanceof Set) {
+    return decodeSetFromSet(registry, ValClass, value);
+  }
+
+  throw new Error('BTreeSet: cannot decode type');
+}
+
+var _ValClass = /*#__PURE__*/_classPrivateFieldLooseKey("ValClass");
+
+export class BTreeSet extends Set {
+  constructor(registry, valType, rawValue) {
+    const [values, decodedLength] = decodeSet(registry, valType, rawValue);
+    super(sortSet(values));
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    this.initialU8aLength = void 0;
+    Object.defineProperty(this, _ValClass, {
+      writable: true,
+      value: void 0
+    });
+    this.registry = registry;
+    this.initialU8aLength = decodedLength;
+    _classPrivateFieldLooseBase(this, _ValClass)[_ValClass] = typeToConstructor(registry, valType);
+  }
+
+  static with(valType) {
+    return class extends BTreeSet {
+      constructor(registry, value) {
+        super(registry, valType, value);
+      }
+
+    };
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    let len = compactToU8a(this.size).length;
+
+    for (const v of this.values()) {
+      len += v.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 The actual set values as a string[]
+   */
+
+
+  get strings() {
+    return [...super.values()].map(v => v.toString());
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return compareSet(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 v of this.values()) {
+      json.push(v.toHuman(isExtended));
+    }
+
+    return json;
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+
+
+  toJSON() {
+    const json = [];
+
+    for (const v of this.values()) {
+      json.push(v.toJSON());
+    }
+
+    return json;
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `BTreeSet<${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 v of this.values()) {
+      encoded.push(v.toU8a(isBare));
+    }
+
+    return u8aConcat(...encoded);
+  }
+
+}