@polkadot/types-codec 6.12.2-2

package/base/VecFixed.js

@@ -0,0 +1,93 @@
+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 { assert, isU8a, u8aConcat } from '@polkadot/util';
+import { AbstractArray } from "../abstract/AbstractArray.js";
+import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
+import { decodeVec } from "./Vec.js";
+/** @internal */
+
+function decodeVecFixed(registry, value, Type, length) {
+  const [values, decodedLength, decodedLengthNoOffset] = decodeVec(registry, Type, value, length);
+
+  while (values.length < length) {
+    values.push(new Type(registry));
+  }
+
+  assert(values.length === length, () => `Expected a length of exactly ${length} entries`);
+  return [values, decodedLength, decodedLengthNoOffset];
+}
+/**
+ * @name VecFixed
+ * @description
+ * This manages codec arrays of a fixed length
+ */
+
+
+var _Type = /*#__PURE__*/_classPrivateFieldLooseKey("Type");
+
+export class VecFixed extends AbstractArray {
+  constructor(registry, Type, length, value = []) {
+    const Clazz = typeToConstructor(registry, Type);
+    const [values,, decodedLengthNoOffset] = isU8a(value) ? decodeU8aVec(registry, value, 0, Clazz, length) : decodeVecFixed(registry, value, Clazz, length);
+    super(registry, values, decodedLengthNoOffset);
+    Object.defineProperty(this, _Type, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _Type)[_Type] = Clazz;
+  }
+
+  static with(Type, length) {
+    return class extends VecFixed {
+      constructor(registry, value) {
+        super(registry, Type, length, value);
+      }
+
+    };
+  }
+  /**
+   * @description The type for the items
+   */
+
+
+  get Type() {
+    return new (_classPrivateFieldLooseBase(this, _Type)[_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;
+  }
+
+  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 = new Array(this.length);
+
+    for (let i = 0; i < this.length; i++) {
+      encoded[i] = this[i].toU8a();
+    }
+
+    return encoded.length ? u8aConcat(...encoded) : new Uint8Array([]);
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType() {
+    return `[${this.Type};${this.length}]`;
+  }
+
+}

package/base/index.cjs

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Base", {
+  enumerable: true,
+  get: function () {
+    return _Base.Base;
+  }
+});
+Object.defineProperty(exports, "Compact", {
+  enumerable: true,
+  get: function () {
+    return _Compact.Compact;
+  }
+});
+Object.defineProperty(exports, "DoNotConstruct", {
+  enumerable: true,
+  get: function () {
+    return _DoNotConstruct.DoNotConstruct;
+  }
+});
+Object.defineProperty(exports, "Enum", {
+  enumerable: true,
+  get: function () {
+    return _Enum.Enum;
+  }
+});
+Object.defineProperty(exports, "Int", {
+  enumerable: true,
+  get: function () {
+    return _Int.Int;
+  }
+});
+Object.defineProperty(exports, "Null", {
+  enumerable: true,
+  get: function () {
+    return _Null.Null;
+  }
+});
+Object.defineProperty(exports, "Option", {
+  enumerable: true,
+  get: function () {
+    return _Option.Option;
+  }
+});
+Object.defineProperty(exports, "Result", {
+  enumerable: true,
+  get: function () {
+    return _Result.Result;
+  }
+});
+Object.defineProperty(exports, "Tuple", {
+  enumerable: true,
+  get: function () {
+    return _Tuple.Tuple;
+  }
+});
+Object.defineProperty(exports, "UInt", {
+  enumerable: true,
+  get: function () {
+    return _UInt.UInt;
+  }
+});
+Object.defineProperty(exports, "Vec", {
+  enumerable: true,
+  get: function () {
+    return _Vec.Vec;
+  }
+});
+Object.defineProperty(exports, "VecAny", {
+  enumerable: true,
+  get: function () {
+    return _VecAny.VecAny;
+  }
+});
+Object.defineProperty(exports, "VecFixed", {
+  enumerable: true,
+  get: function () {
+    return _VecFixed.VecFixed;
+  }
+});
+
+var _Base = require("./Base.cjs");
+
+var _Compact = require("./Compact.cjs");
+
+var _DoNotConstruct = require("./DoNotConstruct.cjs");
+
+var _Enum = require("./Enum.cjs");
+
+var _Int = require("./Int.cjs");
+
+var _Null = require("./Null.cjs");
+
+var _Option = require("./Option.cjs");
+
+var _Result = require("./Result.cjs");
+
+var _Tuple = require("./Tuple.cjs");
+
+var _UInt = require("./UInt.cjs");
+
+var _Vec = require("./Vec.cjs");
+
+var _VecAny = require("./VecAny.cjs");
+
+var _VecFixed = require("./VecFixed.cjs");

package/base/index.d.ts

@@ -0,0 +1,13 @@
+export { Base } from './Base';
+export { Compact } from './Compact';
+export { DoNotConstruct } from './DoNotConstruct';
+export { Enum } from './Enum';
+export { Int } from './Int';
+export { Null } from './Null';
+export { Option } from './Option';
+export { Result } from './Result';
+export { Tuple } from './Tuple';
+export { UInt } from './UInt';
+export { Vec } from './Vec';
+export { VecAny } from './VecAny';
+export { VecFixed } from './VecFixed';

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;